1 /* 2 * This is the new netlink-based wireless configuration interface. 3 * 4 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net> 5 */ 6 7 #include <linux/if.h> 8 #include <linux/module.h> 9 #include <linux/err.h> 10 #include <linux/list.h> 11 #include <linux/if_ether.h> 12 #include <linux/ieee80211.h> 13 #include <linux/nl80211.h> 14 #include <linux/rtnetlink.h> 15 #include <linux/netlink.h> 16 #include <linux/etherdevice.h> 17 #include <net/net_namespace.h> 18 #include <net/genetlink.h> 19 #include <net/cfg80211.h> 20 #include <net/sock.h> 21 #include "core.h" 22 #include "nl80211.h" 23 #include "reg.h" 24 25 /* the netlink family */ 26 static struct genl_family nl80211_fam = { 27 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */ 28 .name = "nl80211", /* have users key off the name instead */ 29 .hdrsize = 0, /* no private header */ 30 .version = 1, /* no particular meaning now */ 31 .maxattr = NL80211_ATTR_MAX, 32 .netnsok = true, 33 }; 34 35 /* internal helper: get rdev and dev */ 36 static int get_rdev_dev_by_info_ifindex(struct genl_info *info, 37 struct cfg80211_registered_device **rdev, 38 struct net_device **dev) 39 { 40 struct nlattr **attrs = info->attrs; 41 int ifindex; 42 43 if (!attrs[NL80211_ATTR_IFINDEX]) 44 return -EINVAL; 45 46 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]); 47 *dev = dev_get_by_index(genl_info_net(info), ifindex); 48 if (!*dev) 49 return -ENODEV; 50 51 *rdev = cfg80211_get_dev_from_ifindex(genl_info_net(info), ifindex); 52 if (IS_ERR(*rdev)) { 53 dev_put(*dev); 54 return PTR_ERR(*rdev); 55 } 56 57 return 0; 58 } 59 60 /* policy for the attributes */ 61 static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = { 62 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 }, 63 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING, 64 .len = 20-1 }, 65 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED }, 66 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 }, 67 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 }, 68 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 }, 69 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 }, 70 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 }, 71 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 }, 72 73 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 }, 74 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 }, 75 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 }, 76 77 [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN }, 78 [NL80211_ATTR_PREV_BSSID] = { .type = NLA_BINARY, .len = ETH_ALEN }, 79 80 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, }, 81 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY, 82 .len = WLAN_MAX_KEY_LEN }, 83 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 }, 84 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 }, 85 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG }, 86 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 }, 87 88 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 }, 89 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 }, 90 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY, 91 .len = IEEE80211_MAX_DATA_LEN }, 92 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY, 93 .len = IEEE80211_MAX_DATA_LEN }, 94 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 }, 95 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED }, 96 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 }, 97 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY, 98 .len = NL80211_MAX_SUPP_RATES }, 99 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 }, 100 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 }, 101 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ }, 102 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY, 103 .len = IEEE80211_MAX_MESH_ID_LEN }, 104 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 }, 105 106 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 }, 107 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED }, 108 109 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 }, 110 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 }, 111 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 }, 112 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY, 113 .len = NL80211_MAX_SUPP_RATES }, 114 115 [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED }, 116 117 [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY, 118 .len = NL80211_HT_CAPABILITY_LEN }, 119 120 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 }, 121 [NL80211_ATTR_IE] = { .type = NLA_BINARY, 122 .len = IEEE80211_MAX_DATA_LEN }, 123 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED }, 124 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED }, 125 126 [NL80211_ATTR_SSID] = { .type = NLA_BINARY, 127 .len = IEEE80211_MAX_SSID_LEN }, 128 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 }, 129 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 }, 130 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG }, 131 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG }, 132 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 }, 133 [NL80211_ATTR_STA_FLAGS2] = { 134 .len = sizeof(struct nl80211_sta_flag_update), 135 }, 136 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG }, 137 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG }, 138 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 }, 139 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 }, 140 [NL80211_ATTR_PID] = { .type = NLA_U32 }, 141 }; 142 143 /* policy for the attributes */ 144 static struct nla_policy 145 nl80211_key_policy[NL80211_KEY_MAX + 1] __read_mostly = { 146 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN }, 147 [NL80211_KEY_IDX] = { .type = NLA_U8 }, 148 [NL80211_KEY_CIPHER] = { .type = NLA_U32 }, 149 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 }, 150 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG }, 151 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG }, 152 }; 153 154 /* IE validation */ 155 static bool is_valid_ie_attr(const struct nlattr *attr) 156 { 157 const u8 *pos; 158 int len; 159 160 if (!attr) 161 return true; 162 163 pos = nla_data(attr); 164 len = nla_len(attr); 165 166 while (len) { 167 u8 elemlen; 168 169 if (len < 2) 170 return false; 171 len -= 2; 172 173 elemlen = pos[1]; 174 if (elemlen > len) 175 return false; 176 177 len -= elemlen; 178 pos += 2 + elemlen; 179 } 180 181 return true; 182 } 183 184 /* message building helper */ 185 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq, 186 int flags, u8 cmd) 187 { 188 /* since there is no private header just add the generic one */ 189 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd); 190 } 191 192 static int nl80211_msg_put_channel(struct sk_buff *msg, 193 struct ieee80211_channel *chan) 194 { 195 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ, 196 chan->center_freq); 197 198 if (chan->flags & IEEE80211_CHAN_DISABLED) 199 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED); 200 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) 201 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN); 202 if (chan->flags & IEEE80211_CHAN_NO_IBSS) 203 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS); 204 if (chan->flags & IEEE80211_CHAN_RADAR) 205 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR); 206 207 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER, 208 DBM_TO_MBM(chan->max_power)); 209 210 return 0; 211 212 nla_put_failure: 213 return -ENOBUFS; 214 } 215 216 /* netlink command implementations */ 217 218 struct key_parse { 219 struct key_params p; 220 int idx; 221 bool def, defmgmt; 222 }; 223 224 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k) 225 { 226 struct nlattr *tb[NL80211_KEY_MAX + 1]; 227 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key, 228 nl80211_key_policy); 229 if (err) 230 return err; 231 232 k->def = !!tb[NL80211_KEY_DEFAULT]; 233 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT]; 234 235 if (tb[NL80211_KEY_IDX]) 236 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]); 237 238 if (tb[NL80211_KEY_DATA]) { 239 k->p.key = nla_data(tb[NL80211_KEY_DATA]); 240 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]); 241 } 242 243 if (tb[NL80211_KEY_SEQ]) { 244 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]); 245 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]); 246 } 247 248 if (tb[NL80211_KEY_CIPHER]) 249 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]); 250 251 return 0; 252 } 253 254 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k) 255 { 256 if (info->attrs[NL80211_ATTR_KEY_DATA]) { 257 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]); 258 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]); 259 } 260 261 if (info->attrs[NL80211_ATTR_KEY_SEQ]) { 262 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]); 263 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]); 264 } 265 266 if (info->attrs[NL80211_ATTR_KEY_IDX]) 267 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]); 268 269 if (info->attrs[NL80211_ATTR_KEY_CIPHER]) 270 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]); 271 272 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT]; 273 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT]; 274 275 return 0; 276 } 277 278 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k) 279 { 280 int err; 281 282 memset(k, 0, sizeof(*k)); 283 k->idx = -1; 284 285 if (info->attrs[NL80211_ATTR_KEY]) 286 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k); 287 else 288 err = nl80211_parse_key_old(info, k); 289 290 if (err) 291 return err; 292 293 if (k->def && k->defmgmt) 294 return -EINVAL; 295 296 if (k->idx != -1) { 297 if (k->defmgmt) { 298 if (k->idx < 4 || k->idx > 5) 299 return -EINVAL; 300 } else if (k->def) { 301 if (k->idx < 0 || k->idx > 3) 302 return -EINVAL; 303 } else { 304 if (k->idx < 0 || k->idx > 5) 305 return -EINVAL; 306 } 307 } 308 309 return 0; 310 } 311 312 static struct cfg80211_cached_keys * 313 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev, 314 struct nlattr *keys) 315 { 316 struct key_parse parse; 317 struct nlattr *key; 318 struct cfg80211_cached_keys *result; 319 int rem, err, def = 0; 320 321 result = kzalloc(sizeof(*result), GFP_KERNEL); 322 if (!result) 323 return ERR_PTR(-ENOMEM); 324 325 result->def = -1; 326 result->defmgmt = -1; 327 328 nla_for_each_nested(key, keys, rem) { 329 memset(&parse, 0, sizeof(parse)); 330 parse.idx = -1; 331 332 err = nl80211_parse_key_new(key, &parse); 333 if (err) 334 goto error; 335 err = -EINVAL; 336 if (!parse.p.key) 337 goto error; 338 if (parse.idx < 0 || parse.idx > 4) 339 goto error; 340 if (parse.def) { 341 if (def) 342 goto error; 343 def = 1; 344 result->def = parse.idx; 345 } else if (parse.defmgmt) 346 goto error; 347 err = cfg80211_validate_key_settings(rdev, &parse.p, 348 parse.idx, NULL); 349 if (err) 350 goto error; 351 result->params[parse.idx].cipher = parse.p.cipher; 352 result->params[parse.idx].key_len = parse.p.key_len; 353 result->params[parse.idx].key = result->data[parse.idx]; 354 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len); 355 } 356 357 return result; 358 error: 359 kfree(result); 360 return ERR_PTR(err); 361 } 362 363 static int nl80211_key_allowed(struct wireless_dev *wdev) 364 { 365 ASSERT_WDEV_LOCK(wdev); 366 367 if (!netif_running(wdev->netdev)) 368 return -ENETDOWN; 369 370 switch (wdev->iftype) { 371 case NL80211_IFTYPE_AP: 372 case NL80211_IFTYPE_AP_VLAN: 373 break; 374 case NL80211_IFTYPE_ADHOC: 375 if (!wdev->current_bss) 376 return -ENOLINK; 377 break; 378 case NL80211_IFTYPE_STATION: 379 if (wdev->sme_state != CFG80211_SME_CONNECTED) 380 return -ENOLINK; 381 break; 382 default: 383 return -EINVAL; 384 } 385 386 return 0; 387 } 388 389 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags, 390 struct cfg80211_registered_device *dev) 391 { 392 void *hdr; 393 struct nlattr *nl_bands, *nl_band; 394 struct nlattr *nl_freqs, *nl_freq; 395 struct nlattr *nl_rates, *nl_rate; 396 struct nlattr *nl_modes; 397 struct nlattr *nl_cmds; 398 enum ieee80211_band band; 399 struct ieee80211_channel *chan; 400 struct ieee80211_rate *rate; 401 int i; 402 u16 ifmodes = dev->wiphy.interface_modes; 403 404 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY); 405 if (!hdr) 406 return -1; 407 408 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx); 409 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy)); 410 411 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, 412 cfg80211_rdev_list_generation); 413 414 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT, 415 dev->wiphy.retry_short); 416 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_LONG, 417 dev->wiphy.retry_long); 418 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD, 419 dev->wiphy.frag_threshold); 420 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD, 421 dev->wiphy.rts_threshold); 422 423 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS, 424 dev->wiphy.max_scan_ssids); 425 NLA_PUT_U16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN, 426 dev->wiphy.max_scan_ie_len); 427 428 NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES, 429 sizeof(u32) * dev->wiphy.n_cipher_suites, 430 dev->wiphy.cipher_suites); 431 432 nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES); 433 if (!nl_modes) 434 goto nla_put_failure; 435 436 i = 0; 437 while (ifmodes) { 438 if (ifmodes & 1) 439 NLA_PUT_FLAG(msg, i); 440 ifmodes >>= 1; 441 i++; 442 } 443 444 nla_nest_end(msg, nl_modes); 445 446 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS); 447 if (!nl_bands) 448 goto nla_put_failure; 449 450 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 451 if (!dev->wiphy.bands[band]) 452 continue; 453 454 nl_band = nla_nest_start(msg, band); 455 if (!nl_band) 456 goto nla_put_failure; 457 458 /* add HT info */ 459 if (dev->wiphy.bands[band]->ht_cap.ht_supported) { 460 NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET, 461 sizeof(dev->wiphy.bands[band]->ht_cap.mcs), 462 &dev->wiphy.bands[band]->ht_cap.mcs); 463 NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA, 464 dev->wiphy.bands[band]->ht_cap.cap); 465 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR, 466 dev->wiphy.bands[band]->ht_cap.ampdu_factor); 467 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY, 468 dev->wiphy.bands[band]->ht_cap.ampdu_density); 469 } 470 471 /* add frequencies */ 472 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS); 473 if (!nl_freqs) 474 goto nla_put_failure; 475 476 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) { 477 nl_freq = nla_nest_start(msg, i); 478 if (!nl_freq) 479 goto nla_put_failure; 480 481 chan = &dev->wiphy.bands[band]->channels[i]; 482 483 if (nl80211_msg_put_channel(msg, chan)) 484 goto nla_put_failure; 485 486 nla_nest_end(msg, nl_freq); 487 } 488 489 nla_nest_end(msg, nl_freqs); 490 491 /* add bitrates */ 492 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES); 493 if (!nl_rates) 494 goto nla_put_failure; 495 496 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) { 497 nl_rate = nla_nest_start(msg, i); 498 if (!nl_rate) 499 goto nla_put_failure; 500 501 rate = &dev->wiphy.bands[band]->bitrates[i]; 502 NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE, 503 rate->bitrate); 504 if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) 505 NLA_PUT_FLAG(msg, 506 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE); 507 508 nla_nest_end(msg, nl_rate); 509 } 510 511 nla_nest_end(msg, nl_rates); 512 513 nla_nest_end(msg, nl_band); 514 } 515 nla_nest_end(msg, nl_bands); 516 517 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS); 518 if (!nl_cmds) 519 goto nla_put_failure; 520 521 i = 0; 522 #define CMD(op, n) \ 523 do { \ 524 if (dev->ops->op) { \ 525 i++; \ 526 NLA_PUT_U32(msg, i, NL80211_CMD_ ## n); \ 527 } \ 528 } while (0) 529 530 CMD(add_virtual_intf, NEW_INTERFACE); 531 CMD(change_virtual_intf, SET_INTERFACE); 532 CMD(add_key, NEW_KEY); 533 CMD(add_beacon, NEW_BEACON); 534 CMD(add_station, NEW_STATION); 535 CMD(add_mpath, NEW_MPATH); 536 CMD(set_mesh_params, SET_MESH_PARAMS); 537 CMD(change_bss, SET_BSS); 538 CMD(auth, AUTHENTICATE); 539 CMD(assoc, ASSOCIATE); 540 CMD(deauth, DEAUTHENTICATE); 541 CMD(disassoc, DISASSOCIATE); 542 CMD(join_ibss, JOIN_IBSS); 543 if (dev->wiphy.netnsok) { 544 i++; 545 NLA_PUT_U32(msg, i, NL80211_CMD_SET_WIPHY_NETNS); 546 } 547 548 #undef CMD 549 550 if (dev->ops->connect || dev->ops->auth) { 551 i++; 552 NLA_PUT_U32(msg, i, NL80211_CMD_CONNECT); 553 } 554 555 if (dev->ops->disconnect || dev->ops->deauth) { 556 i++; 557 NLA_PUT_U32(msg, i, NL80211_CMD_DISCONNECT); 558 } 559 560 nla_nest_end(msg, nl_cmds); 561 562 return genlmsg_end(msg, hdr); 563 564 nla_put_failure: 565 genlmsg_cancel(msg, hdr); 566 return -EMSGSIZE; 567 } 568 569 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb) 570 { 571 int idx = 0; 572 int start = cb->args[0]; 573 struct cfg80211_registered_device *dev; 574 575 mutex_lock(&cfg80211_mutex); 576 list_for_each_entry(dev, &cfg80211_rdev_list, list) { 577 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk))) 578 continue; 579 if (++idx <= start) 580 continue; 581 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid, 582 cb->nlh->nlmsg_seq, NLM_F_MULTI, 583 dev) < 0) { 584 idx--; 585 break; 586 } 587 } 588 mutex_unlock(&cfg80211_mutex); 589 590 cb->args[0] = idx; 591 592 return skb->len; 593 } 594 595 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info) 596 { 597 struct sk_buff *msg; 598 struct cfg80211_registered_device *dev; 599 600 dev = cfg80211_get_dev_from_info(info); 601 if (IS_ERR(dev)) 602 return PTR_ERR(dev); 603 604 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 605 if (!msg) 606 goto out_err; 607 608 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0) 609 goto out_free; 610 611 cfg80211_unlock_rdev(dev); 612 613 return genlmsg_reply(msg, info); 614 615 out_free: 616 nlmsg_free(msg); 617 out_err: 618 cfg80211_unlock_rdev(dev); 619 return -ENOBUFS; 620 } 621 622 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = { 623 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 }, 624 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 }, 625 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 }, 626 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 }, 627 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 }, 628 }; 629 630 static int parse_txq_params(struct nlattr *tb[], 631 struct ieee80211_txq_params *txq_params) 632 { 633 if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] || 634 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] || 635 !tb[NL80211_TXQ_ATTR_AIFS]) 636 return -EINVAL; 637 638 txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]); 639 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]); 640 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]); 641 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]); 642 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]); 643 644 return 0; 645 } 646 647 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info) 648 { 649 struct cfg80211_registered_device *rdev; 650 int result = 0, rem_txq_params = 0; 651 struct nlattr *nl_txq_params; 652 u32 changed; 653 u8 retry_short = 0, retry_long = 0; 654 u32 frag_threshold = 0, rts_threshold = 0; 655 656 rtnl_lock(); 657 658 mutex_lock(&cfg80211_mutex); 659 660 rdev = __cfg80211_rdev_from_info(info); 661 if (IS_ERR(rdev)) { 662 mutex_unlock(&cfg80211_mutex); 663 result = PTR_ERR(rdev); 664 goto unlock; 665 } 666 667 mutex_lock(&rdev->mtx); 668 669 if (info->attrs[NL80211_ATTR_WIPHY_NAME]) 670 result = cfg80211_dev_rename( 671 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME])); 672 673 mutex_unlock(&cfg80211_mutex); 674 675 if (result) 676 goto bad_res; 677 678 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) { 679 struct ieee80211_txq_params txq_params; 680 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1]; 681 682 if (!rdev->ops->set_txq_params) { 683 result = -EOPNOTSUPP; 684 goto bad_res; 685 } 686 687 nla_for_each_nested(nl_txq_params, 688 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS], 689 rem_txq_params) { 690 nla_parse(tb, NL80211_TXQ_ATTR_MAX, 691 nla_data(nl_txq_params), 692 nla_len(nl_txq_params), 693 txq_params_policy); 694 result = parse_txq_params(tb, &txq_params); 695 if (result) 696 goto bad_res; 697 698 result = rdev->ops->set_txq_params(&rdev->wiphy, 699 &txq_params); 700 if (result) 701 goto bad_res; 702 } 703 } 704 705 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) { 706 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT; 707 u32 freq; 708 709 result = -EINVAL; 710 711 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) { 712 channel_type = nla_get_u32(info->attrs[ 713 NL80211_ATTR_WIPHY_CHANNEL_TYPE]); 714 if (channel_type != NL80211_CHAN_NO_HT && 715 channel_type != NL80211_CHAN_HT20 && 716 channel_type != NL80211_CHAN_HT40PLUS && 717 channel_type != NL80211_CHAN_HT40MINUS) 718 goto bad_res; 719 } 720 721 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]); 722 723 mutex_lock(&rdev->devlist_mtx); 724 result = rdev_set_freq(rdev, NULL, freq, channel_type); 725 mutex_unlock(&rdev->devlist_mtx); 726 if (result) 727 goto bad_res; 728 } 729 730 changed = 0; 731 732 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) { 733 retry_short = nla_get_u8( 734 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]); 735 if (retry_short == 0) { 736 result = -EINVAL; 737 goto bad_res; 738 } 739 changed |= WIPHY_PARAM_RETRY_SHORT; 740 } 741 742 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) { 743 retry_long = nla_get_u8( 744 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]); 745 if (retry_long == 0) { 746 result = -EINVAL; 747 goto bad_res; 748 } 749 changed |= WIPHY_PARAM_RETRY_LONG; 750 } 751 752 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) { 753 frag_threshold = nla_get_u32( 754 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]); 755 if (frag_threshold < 256) { 756 result = -EINVAL; 757 goto bad_res; 758 } 759 if (frag_threshold != (u32) -1) { 760 /* 761 * Fragments (apart from the last one) are required to 762 * have even length. Make the fragmentation code 763 * simpler by stripping LSB should someone try to use 764 * odd threshold value. 765 */ 766 frag_threshold &= ~0x1; 767 } 768 changed |= WIPHY_PARAM_FRAG_THRESHOLD; 769 } 770 771 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) { 772 rts_threshold = nla_get_u32( 773 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]); 774 changed |= WIPHY_PARAM_RTS_THRESHOLD; 775 } 776 777 if (changed) { 778 u8 old_retry_short, old_retry_long; 779 u32 old_frag_threshold, old_rts_threshold; 780 781 if (!rdev->ops->set_wiphy_params) { 782 result = -EOPNOTSUPP; 783 goto bad_res; 784 } 785 786 old_retry_short = rdev->wiphy.retry_short; 787 old_retry_long = rdev->wiphy.retry_long; 788 old_frag_threshold = rdev->wiphy.frag_threshold; 789 old_rts_threshold = rdev->wiphy.rts_threshold; 790 791 if (changed & WIPHY_PARAM_RETRY_SHORT) 792 rdev->wiphy.retry_short = retry_short; 793 if (changed & WIPHY_PARAM_RETRY_LONG) 794 rdev->wiphy.retry_long = retry_long; 795 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) 796 rdev->wiphy.frag_threshold = frag_threshold; 797 if (changed & WIPHY_PARAM_RTS_THRESHOLD) 798 rdev->wiphy.rts_threshold = rts_threshold; 799 800 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed); 801 if (result) { 802 rdev->wiphy.retry_short = old_retry_short; 803 rdev->wiphy.retry_long = old_retry_long; 804 rdev->wiphy.frag_threshold = old_frag_threshold; 805 rdev->wiphy.rts_threshold = old_rts_threshold; 806 } 807 } 808 809 bad_res: 810 mutex_unlock(&rdev->mtx); 811 unlock: 812 rtnl_unlock(); 813 return result; 814 } 815 816 817 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags, 818 struct cfg80211_registered_device *rdev, 819 struct net_device *dev) 820 { 821 void *hdr; 822 823 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE); 824 if (!hdr) 825 return -1; 826 827 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex); 828 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 829 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name); 830 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype); 831 832 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, 833 rdev->devlist_generation ^ 834 (cfg80211_rdev_list_generation << 2)); 835 836 return genlmsg_end(msg, hdr); 837 838 nla_put_failure: 839 genlmsg_cancel(msg, hdr); 840 return -EMSGSIZE; 841 } 842 843 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb) 844 { 845 int wp_idx = 0; 846 int if_idx = 0; 847 int wp_start = cb->args[0]; 848 int if_start = cb->args[1]; 849 struct cfg80211_registered_device *rdev; 850 struct wireless_dev *wdev; 851 852 mutex_lock(&cfg80211_mutex); 853 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 854 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk))) 855 continue; 856 if (wp_idx < wp_start) { 857 wp_idx++; 858 continue; 859 } 860 if_idx = 0; 861 862 mutex_lock(&rdev->devlist_mtx); 863 list_for_each_entry(wdev, &rdev->netdev_list, list) { 864 if (if_idx < if_start) { 865 if_idx++; 866 continue; 867 } 868 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid, 869 cb->nlh->nlmsg_seq, NLM_F_MULTI, 870 rdev, wdev->netdev) < 0) { 871 mutex_unlock(&rdev->devlist_mtx); 872 goto out; 873 } 874 if_idx++; 875 } 876 mutex_unlock(&rdev->devlist_mtx); 877 878 wp_idx++; 879 } 880 out: 881 mutex_unlock(&cfg80211_mutex); 882 883 cb->args[0] = wp_idx; 884 cb->args[1] = if_idx; 885 886 return skb->len; 887 } 888 889 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info) 890 { 891 struct sk_buff *msg; 892 struct cfg80211_registered_device *dev; 893 struct net_device *netdev; 894 int err; 895 896 err = get_rdev_dev_by_info_ifindex(info, &dev, &netdev); 897 if (err) 898 return err; 899 900 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 901 if (!msg) 902 goto out_err; 903 904 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0, 905 dev, netdev) < 0) 906 goto out_free; 907 908 dev_put(netdev); 909 cfg80211_unlock_rdev(dev); 910 911 return genlmsg_reply(msg, info); 912 913 out_free: 914 nlmsg_free(msg); 915 out_err: 916 dev_put(netdev); 917 cfg80211_unlock_rdev(dev); 918 return -ENOBUFS; 919 } 920 921 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = { 922 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG }, 923 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG }, 924 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG }, 925 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG }, 926 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG }, 927 }; 928 929 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags) 930 { 931 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1]; 932 int flag; 933 934 *mntrflags = 0; 935 936 if (!nla) 937 return -EINVAL; 938 939 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX, 940 nla, mntr_flags_policy)) 941 return -EINVAL; 942 943 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++) 944 if (flags[flag]) 945 *mntrflags |= (1<<flag); 946 947 return 0; 948 } 949 950 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info) 951 { 952 struct cfg80211_registered_device *rdev; 953 struct vif_params params; 954 int err; 955 enum nl80211_iftype otype, ntype; 956 struct net_device *dev; 957 u32 _flags, *flags = NULL; 958 bool change = false; 959 960 memset(¶ms, 0, sizeof(params)); 961 962 rtnl_lock(); 963 964 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 965 if (err) 966 goto unlock_rtnl; 967 968 otype = ntype = dev->ieee80211_ptr->iftype; 969 970 if (info->attrs[NL80211_ATTR_IFTYPE]) { 971 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]); 972 if (otype != ntype) 973 change = true; 974 if (ntype > NL80211_IFTYPE_MAX) { 975 err = -EINVAL; 976 goto unlock; 977 } 978 } 979 980 if (info->attrs[NL80211_ATTR_MESH_ID]) { 981 if (ntype != NL80211_IFTYPE_MESH_POINT) { 982 err = -EINVAL; 983 goto unlock; 984 } 985 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]); 986 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]); 987 change = true; 988 } 989 990 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) { 991 if (ntype != NL80211_IFTYPE_MONITOR) { 992 err = -EINVAL; 993 goto unlock; 994 } 995 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS], 996 &_flags); 997 if (err) 998 goto unlock; 999 1000 flags = &_flags; 1001 change = true; 1002 } 1003 1004 if (change) 1005 err = cfg80211_change_iface(rdev, dev, ntype, flags, ¶ms); 1006 else 1007 err = 0; 1008 1009 unlock: 1010 dev_put(dev); 1011 cfg80211_unlock_rdev(rdev); 1012 unlock_rtnl: 1013 rtnl_unlock(); 1014 return err; 1015 } 1016 1017 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info) 1018 { 1019 struct cfg80211_registered_device *rdev; 1020 struct vif_params params; 1021 int err; 1022 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED; 1023 u32 flags; 1024 1025 memset(¶ms, 0, sizeof(params)); 1026 1027 if (!info->attrs[NL80211_ATTR_IFNAME]) 1028 return -EINVAL; 1029 1030 if (info->attrs[NL80211_ATTR_IFTYPE]) { 1031 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]); 1032 if (type > NL80211_IFTYPE_MAX) 1033 return -EINVAL; 1034 } 1035 1036 rtnl_lock(); 1037 1038 rdev = cfg80211_get_dev_from_info(info); 1039 if (IS_ERR(rdev)) { 1040 err = PTR_ERR(rdev); 1041 goto unlock_rtnl; 1042 } 1043 1044 if (!rdev->ops->add_virtual_intf || 1045 !(rdev->wiphy.interface_modes & (1 << type))) { 1046 err = -EOPNOTSUPP; 1047 goto unlock; 1048 } 1049 1050 if (type == NL80211_IFTYPE_MESH_POINT && 1051 info->attrs[NL80211_ATTR_MESH_ID]) { 1052 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]); 1053 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]); 1054 } 1055 1056 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ? 1057 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL, 1058 &flags); 1059 err = rdev->ops->add_virtual_intf(&rdev->wiphy, 1060 nla_data(info->attrs[NL80211_ATTR_IFNAME]), 1061 type, err ? NULL : &flags, ¶ms); 1062 1063 unlock: 1064 cfg80211_unlock_rdev(rdev); 1065 unlock_rtnl: 1066 rtnl_unlock(); 1067 return err; 1068 } 1069 1070 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info) 1071 { 1072 struct cfg80211_registered_device *rdev; 1073 int err; 1074 struct net_device *dev; 1075 1076 rtnl_lock(); 1077 1078 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1079 if (err) 1080 goto unlock_rtnl; 1081 1082 if (!rdev->ops->del_virtual_intf) { 1083 err = -EOPNOTSUPP; 1084 goto out; 1085 } 1086 1087 err = rdev->ops->del_virtual_intf(&rdev->wiphy, dev); 1088 1089 out: 1090 cfg80211_unlock_rdev(rdev); 1091 dev_put(dev); 1092 unlock_rtnl: 1093 rtnl_unlock(); 1094 return err; 1095 } 1096 1097 struct get_key_cookie { 1098 struct sk_buff *msg; 1099 int error; 1100 int idx; 1101 }; 1102 1103 static void get_key_callback(void *c, struct key_params *params) 1104 { 1105 struct nlattr *key; 1106 struct get_key_cookie *cookie = c; 1107 1108 if (params->key) 1109 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA, 1110 params->key_len, params->key); 1111 1112 if (params->seq) 1113 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ, 1114 params->seq_len, params->seq); 1115 1116 if (params->cipher) 1117 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER, 1118 params->cipher); 1119 1120 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY); 1121 if (!key) 1122 goto nla_put_failure; 1123 1124 if (params->key) 1125 NLA_PUT(cookie->msg, NL80211_KEY_DATA, 1126 params->key_len, params->key); 1127 1128 if (params->seq) 1129 NLA_PUT(cookie->msg, NL80211_KEY_SEQ, 1130 params->seq_len, params->seq); 1131 1132 if (params->cipher) 1133 NLA_PUT_U32(cookie->msg, NL80211_KEY_CIPHER, 1134 params->cipher); 1135 1136 NLA_PUT_U8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx); 1137 1138 nla_nest_end(cookie->msg, key); 1139 1140 return; 1141 nla_put_failure: 1142 cookie->error = 1; 1143 } 1144 1145 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info) 1146 { 1147 struct cfg80211_registered_device *rdev; 1148 int err; 1149 struct net_device *dev; 1150 u8 key_idx = 0; 1151 u8 *mac_addr = NULL; 1152 struct get_key_cookie cookie = { 1153 .error = 0, 1154 }; 1155 void *hdr; 1156 struct sk_buff *msg; 1157 1158 if (info->attrs[NL80211_ATTR_KEY_IDX]) 1159 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]); 1160 1161 if (key_idx > 5) 1162 return -EINVAL; 1163 1164 if (info->attrs[NL80211_ATTR_MAC]) 1165 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 1166 1167 rtnl_lock(); 1168 1169 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1170 if (err) 1171 goto unlock_rtnl; 1172 1173 if (!rdev->ops->get_key) { 1174 err = -EOPNOTSUPP; 1175 goto out; 1176 } 1177 1178 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1179 if (!msg) { 1180 err = -ENOMEM; 1181 goto out; 1182 } 1183 1184 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0, 1185 NL80211_CMD_NEW_KEY); 1186 1187 if (IS_ERR(hdr)) { 1188 err = PTR_ERR(hdr); 1189 goto free_msg; 1190 } 1191 1192 cookie.msg = msg; 1193 cookie.idx = key_idx; 1194 1195 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex); 1196 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx); 1197 if (mac_addr) 1198 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr); 1199 1200 err = rdev->ops->get_key(&rdev->wiphy, dev, key_idx, mac_addr, 1201 &cookie, get_key_callback); 1202 1203 if (err) 1204 goto free_msg; 1205 1206 if (cookie.error) 1207 goto nla_put_failure; 1208 1209 genlmsg_end(msg, hdr); 1210 err = genlmsg_reply(msg, info); 1211 goto out; 1212 1213 nla_put_failure: 1214 err = -ENOBUFS; 1215 free_msg: 1216 nlmsg_free(msg); 1217 out: 1218 cfg80211_unlock_rdev(rdev); 1219 dev_put(dev); 1220 unlock_rtnl: 1221 rtnl_unlock(); 1222 1223 return err; 1224 } 1225 1226 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info) 1227 { 1228 struct cfg80211_registered_device *rdev; 1229 struct key_parse key; 1230 int err; 1231 struct net_device *dev; 1232 int (*func)(struct wiphy *wiphy, struct net_device *netdev, 1233 u8 key_index); 1234 1235 err = nl80211_parse_key(info, &key); 1236 if (err) 1237 return err; 1238 1239 if (key.idx < 0) 1240 return -EINVAL; 1241 1242 /* only support setting default key */ 1243 if (!key.def && !key.defmgmt) 1244 return -EINVAL; 1245 1246 rtnl_lock(); 1247 1248 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1249 if (err) 1250 goto unlock_rtnl; 1251 1252 if (key.def) 1253 func = rdev->ops->set_default_key; 1254 else 1255 func = rdev->ops->set_default_mgmt_key; 1256 1257 if (!func) { 1258 err = -EOPNOTSUPP; 1259 goto out; 1260 } 1261 1262 wdev_lock(dev->ieee80211_ptr); 1263 err = nl80211_key_allowed(dev->ieee80211_ptr); 1264 if (!err) 1265 err = func(&rdev->wiphy, dev, key.idx); 1266 1267 #ifdef CONFIG_WIRELESS_EXT 1268 if (!err) { 1269 if (func == rdev->ops->set_default_key) 1270 dev->ieee80211_ptr->wext.default_key = key.idx; 1271 else 1272 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx; 1273 } 1274 #endif 1275 wdev_unlock(dev->ieee80211_ptr); 1276 1277 out: 1278 cfg80211_unlock_rdev(rdev); 1279 dev_put(dev); 1280 1281 unlock_rtnl: 1282 rtnl_unlock(); 1283 1284 return err; 1285 } 1286 1287 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info) 1288 { 1289 struct cfg80211_registered_device *rdev; 1290 int err; 1291 struct net_device *dev; 1292 struct key_parse key; 1293 u8 *mac_addr = NULL; 1294 1295 err = nl80211_parse_key(info, &key); 1296 if (err) 1297 return err; 1298 1299 if (!key.p.key) 1300 return -EINVAL; 1301 1302 if (info->attrs[NL80211_ATTR_MAC]) 1303 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 1304 1305 rtnl_lock(); 1306 1307 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1308 if (err) 1309 goto unlock_rtnl; 1310 1311 if (!rdev->ops->add_key) { 1312 err = -EOPNOTSUPP; 1313 goto out; 1314 } 1315 1316 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx, mac_addr)) { 1317 err = -EINVAL; 1318 goto out; 1319 } 1320 1321 wdev_lock(dev->ieee80211_ptr); 1322 err = nl80211_key_allowed(dev->ieee80211_ptr); 1323 if (!err) 1324 err = rdev->ops->add_key(&rdev->wiphy, dev, key.idx, 1325 mac_addr, &key.p); 1326 wdev_unlock(dev->ieee80211_ptr); 1327 1328 out: 1329 cfg80211_unlock_rdev(rdev); 1330 dev_put(dev); 1331 unlock_rtnl: 1332 rtnl_unlock(); 1333 1334 return err; 1335 } 1336 1337 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info) 1338 { 1339 struct cfg80211_registered_device *rdev; 1340 int err; 1341 struct net_device *dev; 1342 u8 *mac_addr = NULL; 1343 struct key_parse key; 1344 1345 err = nl80211_parse_key(info, &key); 1346 if (err) 1347 return err; 1348 1349 if (info->attrs[NL80211_ATTR_MAC]) 1350 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 1351 1352 rtnl_lock(); 1353 1354 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1355 if (err) 1356 goto unlock_rtnl; 1357 1358 if (!rdev->ops->del_key) { 1359 err = -EOPNOTSUPP; 1360 goto out; 1361 } 1362 1363 wdev_lock(dev->ieee80211_ptr); 1364 err = nl80211_key_allowed(dev->ieee80211_ptr); 1365 if (!err) 1366 err = rdev->ops->del_key(&rdev->wiphy, dev, key.idx, mac_addr); 1367 1368 #ifdef CONFIG_WIRELESS_EXT 1369 if (!err) { 1370 if (key.idx == dev->ieee80211_ptr->wext.default_key) 1371 dev->ieee80211_ptr->wext.default_key = -1; 1372 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key) 1373 dev->ieee80211_ptr->wext.default_mgmt_key = -1; 1374 } 1375 #endif 1376 wdev_unlock(dev->ieee80211_ptr); 1377 1378 out: 1379 cfg80211_unlock_rdev(rdev); 1380 dev_put(dev); 1381 1382 unlock_rtnl: 1383 rtnl_unlock(); 1384 1385 return err; 1386 } 1387 1388 static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info) 1389 { 1390 int (*call)(struct wiphy *wiphy, struct net_device *dev, 1391 struct beacon_parameters *info); 1392 struct cfg80211_registered_device *rdev; 1393 int err; 1394 struct net_device *dev; 1395 struct beacon_parameters params; 1396 int haveinfo = 0; 1397 1398 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL])) 1399 return -EINVAL; 1400 1401 rtnl_lock(); 1402 1403 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1404 if (err) 1405 goto unlock_rtnl; 1406 1407 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) { 1408 err = -EOPNOTSUPP; 1409 goto out; 1410 } 1411 1412 switch (info->genlhdr->cmd) { 1413 case NL80211_CMD_NEW_BEACON: 1414 /* these are required for NEW_BEACON */ 1415 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] || 1416 !info->attrs[NL80211_ATTR_DTIM_PERIOD] || 1417 !info->attrs[NL80211_ATTR_BEACON_HEAD]) { 1418 err = -EINVAL; 1419 goto out; 1420 } 1421 1422 call = rdev->ops->add_beacon; 1423 break; 1424 case NL80211_CMD_SET_BEACON: 1425 call = rdev->ops->set_beacon; 1426 break; 1427 default: 1428 WARN_ON(1); 1429 err = -EOPNOTSUPP; 1430 goto out; 1431 } 1432 1433 if (!call) { 1434 err = -EOPNOTSUPP; 1435 goto out; 1436 } 1437 1438 memset(¶ms, 0, sizeof(params)); 1439 1440 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) { 1441 params.interval = 1442 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]); 1443 haveinfo = 1; 1444 } 1445 1446 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) { 1447 params.dtim_period = 1448 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]); 1449 haveinfo = 1; 1450 } 1451 1452 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) { 1453 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]); 1454 params.head_len = 1455 nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]); 1456 haveinfo = 1; 1457 } 1458 1459 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) { 1460 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]); 1461 params.tail_len = 1462 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]); 1463 haveinfo = 1; 1464 } 1465 1466 if (!haveinfo) { 1467 err = -EINVAL; 1468 goto out; 1469 } 1470 1471 err = call(&rdev->wiphy, dev, ¶ms); 1472 1473 out: 1474 cfg80211_unlock_rdev(rdev); 1475 dev_put(dev); 1476 unlock_rtnl: 1477 rtnl_unlock(); 1478 1479 return err; 1480 } 1481 1482 static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info) 1483 { 1484 struct cfg80211_registered_device *rdev; 1485 int err; 1486 struct net_device *dev; 1487 1488 rtnl_lock(); 1489 1490 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1491 if (err) 1492 goto unlock_rtnl; 1493 1494 if (!rdev->ops->del_beacon) { 1495 err = -EOPNOTSUPP; 1496 goto out; 1497 } 1498 1499 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) { 1500 err = -EOPNOTSUPP; 1501 goto out; 1502 } 1503 err = rdev->ops->del_beacon(&rdev->wiphy, dev); 1504 1505 out: 1506 cfg80211_unlock_rdev(rdev); 1507 dev_put(dev); 1508 unlock_rtnl: 1509 rtnl_unlock(); 1510 1511 return err; 1512 } 1513 1514 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = { 1515 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG }, 1516 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG }, 1517 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG }, 1518 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG }, 1519 }; 1520 1521 static int parse_station_flags(struct genl_info *info, 1522 struct station_parameters *params) 1523 { 1524 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1]; 1525 struct nlattr *nla; 1526 int flag; 1527 1528 /* 1529 * Try parsing the new attribute first so userspace 1530 * can specify both for older kernels. 1531 */ 1532 nla = info->attrs[NL80211_ATTR_STA_FLAGS2]; 1533 if (nla) { 1534 struct nl80211_sta_flag_update *sta_flags; 1535 1536 sta_flags = nla_data(nla); 1537 params->sta_flags_mask = sta_flags->mask; 1538 params->sta_flags_set = sta_flags->set; 1539 if ((params->sta_flags_mask | 1540 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID)) 1541 return -EINVAL; 1542 return 0; 1543 } 1544 1545 /* if present, parse the old attribute */ 1546 1547 nla = info->attrs[NL80211_ATTR_STA_FLAGS]; 1548 if (!nla) 1549 return 0; 1550 1551 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX, 1552 nla, sta_flags_policy)) 1553 return -EINVAL; 1554 1555 params->sta_flags_mask = (1 << __NL80211_STA_FLAG_AFTER_LAST) - 1; 1556 params->sta_flags_mask &= ~1; 1557 1558 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) 1559 if (flags[flag]) 1560 params->sta_flags_set |= (1<<flag); 1561 1562 return 0; 1563 } 1564 1565 static u16 nl80211_calculate_bitrate(struct rate_info *rate) 1566 { 1567 int modulation, streams, bitrate; 1568 1569 if (!(rate->flags & RATE_INFO_FLAGS_MCS)) 1570 return rate->legacy; 1571 1572 /* the formula below does only work for MCS values smaller than 32 */ 1573 if (rate->mcs >= 32) 1574 return 0; 1575 1576 modulation = rate->mcs & 7; 1577 streams = (rate->mcs >> 3) + 1; 1578 1579 bitrate = (rate->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) ? 1580 13500000 : 6500000; 1581 1582 if (modulation < 4) 1583 bitrate *= (modulation + 1); 1584 else if (modulation == 4) 1585 bitrate *= (modulation + 2); 1586 else 1587 bitrate *= (modulation + 3); 1588 1589 bitrate *= streams; 1590 1591 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI) 1592 bitrate = (bitrate / 9) * 10; 1593 1594 /* do NOT round down here */ 1595 return (bitrate + 50000) / 100000; 1596 } 1597 1598 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq, 1599 int flags, struct net_device *dev, 1600 u8 *mac_addr, struct station_info *sinfo) 1601 { 1602 void *hdr; 1603 struct nlattr *sinfoattr, *txrate; 1604 u16 bitrate; 1605 1606 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION); 1607 if (!hdr) 1608 return -1; 1609 1610 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex); 1611 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr); 1612 1613 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, sinfo->generation); 1614 1615 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO); 1616 if (!sinfoattr) 1617 goto nla_put_failure; 1618 if (sinfo->filled & STATION_INFO_INACTIVE_TIME) 1619 NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME, 1620 sinfo->inactive_time); 1621 if (sinfo->filled & STATION_INFO_RX_BYTES) 1622 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES, 1623 sinfo->rx_bytes); 1624 if (sinfo->filled & STATION_INFO_TX_BYTES) 1625 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES, 1626 sinfo->tx_bytes); 1627 if (sinfo->filled & STATION_INFO_LLID) 1628 NLA_PUT_U16(msg, NL80211_STA_INFO_LLID, 1629 sinfo->llid); 1630 if (sinfo->filled & STATION_INFO_PLID) 1631 NLA_PUT_U16(msg, NL80211_STA_INFO_PLID, 1632 sinfo->plid); 1633 if (sinfo->filled & STATION_INFO_PLINK_STATE) 1634 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE, 1635 sinfo->plink_state); 1636 if (sinfo->filled & STATION_INFO_SIGNAL) 1637 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL, 1638 sinfo->signal); 1639 if (sinfo->filled & STATION_INFO_TX_BITRATE) { 1640 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE); 1641 if (!txrate) 1642 goto nla_put_failure; 1643 1644 /* nl80211_calculate_bitrate will return 0 for mcs >= 32 */ 1645 bitrate = nl80211_calculate_bitrate(&sinfo->txrate); 1646 if (bitrate > 0) 1647 NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate); 1648 1649 if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS) 1650 NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS, 1651 sinfo->txrate.mcs); 1652 if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) 1653 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH); 1654 if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI) 1655 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI); 1656 1657 nla_nest_end(msg, txrate); 1658 } 1659 if (sinfo->filled & STATION_INFO_RX_PACKETS) 1660 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_PACKETS, 1661 sinfo->rx_packets); 1662 if (sinfo->filled & STATION_INFO_TX_PACKETS) 1663 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_PACKETS, 1664 sinfo->tx_packets); 1665 nla_nest_end(msg, sinfoattr); 1666 1667 return genlmsg_end(msg, hdr); 1668 1669 nla_put_failure: 1670 genlmsg_cancel(msg, hdr); 1671 return -EMSGSIZE; 1672 } 1673 1674 static int nl80211_dump_station(struct sk_buff *skb, 1675 struct netlink_callback *cb) 1676 { 1677 struct station_info sinfo; 1678 struct cfg80211_registered_device *dev; 1679 struct net_device *netdev; 1680 u8 mac_addr[ETH_ALEN]; 1681 int ifidx = cb->args[0]; 1682 int sta_idx = cb->args[1]; 1683 int err; 1684 1685 if (!ifidx) { 1686 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, 1687 nl80211_fam.attrbuf, nl80211_fam.maxattr, 1688 nl80211_policy); 1689 if (err) 1690 return err; 1691 1692 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]) 1693 return -EINVAL; 1694 1695 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]); 1696 if (!ifidx) 1697 return -EINVAL; 1698 } 1699 1700 rtnl_lock(); 1701 1702 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx); 1703 if (!netdev) { 1704 err = -ENODEV; 1705 goto out_rtnl; 1706 } 1707 1708 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx); 1709 if (IS_ERR(dev)) { 1710 err = PTR_ERR(dev); 1711 goto out_rtnl; 1712 } 1713 1714 if (!dev->ops->dump_station) { 1715 err = -EOPNOTSUPP; 1716 goto out_err; 1717 } 1718 1719 while (1) { 1720 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx, 1721 mac_addr, &sinfo); 1722 if (err == -ENOENT) 1723 break; 1724 if (err) 1725 goto out_err; 1726 1727 if (nl80211_send_station(skb, 1728 NETLINK_CB(cb->skb).pid, 1729 cb->nlh->nlmsg_seq, NLM_F_MULTI, 1730 netdev, mac_addr, 1731 &sinfo) < 0) 1732 goto out; 1733 1734 sta_idx++; 1735 } 1736 1737 1738 out: 1739 cb->args[1] = sta_idx; 1740 err = skb->len; 1741 out_err: 1742 cfg80211_unlock_rdev(dev); 1743 out_rtnl: 1744 rtnl_unlock(); 1745 1746 return err; 1747 } 1748 1749 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info) 1750 { 1751 struct cfg80211_registered_device *rdev; 1752 int err; 1753 struct net_device *dev; 1754 struct station_info sinfo; 1755 struct sk_buff *msg; 1756 u8 *mac_addr = NULL; 1757 1758 memset(&sinfo, 0, sizeof(sinfo)); 1759 1760 if (!info->attrs[NL80211_ATTR_MAC]) 1761 return -EINVAL; 1762 1763 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 1764 1765 rtnl_lock(); 1766 1767 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1768 if (err) 1769 goto out_rtnl; 1770 1771 if (!rdev->ops->get_station) { 1772 err = -EOPNOTSUPP; 1773 goto out; 1774 } 1775 1776 err = rdev->ops->get_station(&rdev->wiphy, dev, mac_addr, &sinfo); 1777 if (err) 1778 goto out; 1779 1780 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1781 if (!msg) 1782 goto out; 1783 1784 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0, 1785 dev, mac_addr, &sinfo) < 0) 1786 goto out_free; 1787 1788 err = genlmsg_reply(msg, info); 1789 goto out; 1790 1791 out_free: 1792 nlmsg_free(msg); 1793 out: 1794 cfg80211_unlock_rdev(rdev); 1795 dev_put(dev); 1796 out_rtnl: 1797 rtnl_unlock(); 1798 1799 return err; 1800 } 1801 1802 /* 1803 * Get vlan interface making sure it is on the right wiphy. 1804 */ 1805 static int get_vlan(struct genl_info *info, 1806 struct cfg80211_registered_device *rdev, 1807 struct net_device **vlan) 1808 { 1809 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN]; 1810 *vlan = NULL; 1811 1812 if (vlanattr) { 1813 *vlan = dev_get_by_index(genl_info_net(info), 1814 nla_get_u32(vlanattr)); 1815 if (!*vlan) 1816 return -ENODEV; 1817 if (!(*vlan)->ieee80211_ptr) 1818 return -EINVAL; 1819 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy) 1820 return -EINVAL; 1821 } 1822 return 0; 1823 } 1824 1825 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info) 1826 { 1827 struct cfg80211_registered_device *rdev; 1828 int err; 1829 struct net_device *dev; 1830 struct station_parameters params; 1831 u8 *mac_addr = NULL; 1832 1833 memset(¶ms, 0, sizeof(params)); 1834 1835 params.listen_interval = -1; 1836 1837 if (info->attrs[NL80211_ATTR_STA_AID]) 1838 return -EINVAL; 1839 1840 if (!info->attrs[NL80211_ATTR_MAC]) 1841 return -EINVAL; 1842 1843 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 1844 1845 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) { 1846 params.supported_rates = 1847 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 1848 params.supported_rates_len = 1849 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 1850 } 1851 1852 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]) 1853 params.listen_interval = 1854 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]); 1855 1856 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) 1857 params.ht_capa = 1858 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]); 1859 1860 if (parse_station_flags(info, ¶ms)) 1861 return -EINVAL; 1862 1863 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) 1864 params.plink_action = 1865 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]); 1866 1867 rtnl_lock(); 1868 1869 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1870 if (err) 1871 goto out_rtnl; 1872 1873 err = get_vlan(info, rdev, ¶ms.vlan); 1874 if (err) 1875 goto out; 1876 1877 /* validate settings */ 1878 err = 0; 1879 1880 switch (dev->ieee80211_ptr->iftype) { 1881 case NL80211_IFTYPE_AP: 1882 case NL80211_IFTYPE_AP_VLAN: 1883 /* disallow mesh-specific things */ 1884 if (params.plink_action) 1885 err = -EINVAL; 1886 break; 1887 case NL80211_IFTYPE_STATION: 1888 /* disallow everything but AUTHORIZED flag */ 1889 if (params.plink_action) 1890 err = -EINVAL; 1891 if (params.vlan) 1892 err = -EINVAL; 1893 if (params.supported_rates) 1894 err = -EINVAL; 1895 if (params.ht_capa) 1896 err = -EINVAL; 1897 if (params.listen_interval >= 0) 1898 err = -EINVAL; 1899 if (params.sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED)) 1900 err = -EINVAL; 1901 break; 1902 case NL80211_IFTYPE_MESH_POINT: 1903 /* disallow things mesh doesn't support */ 1904 if (params.vlan) 1905 err = -EINVAL; 1906 if (params.ht_capa) 1907 err = -EINVAL; 1908 if (params.listen_interval >= 0) 1909 err = -EINVAL; 1910 if (params.supported_rates) 1911 err = -EINVAL; 1912 if (params.sta_flags_mask) 1913 err = -EINVAL; 1914 break; 1915 default: 1916 err = -EINVAL; 1917 } 1918 1919 if (err) 1920 goto out; 1921 1922 if (!rdev->ops->change_station) { 1923 err = -EOPNOTSUPP; 1924 goto out; 1925 } 1926 1927 err = rdev->ops->change_station(&rdev->wiphy, dev, mac_addr, ¶ms); 1928 1929 out: 1930 if (params.vlan) 1931 dev_put(params.vlan); 1932 cfg80211_unlock_rdev(rdev); 1933 dev_put(dev); 1934 out_rtnl: 1935 rtnl_unlock(); 1936 1937 return err; 1938 } 1939 1940 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info) 1941 { 1942 struct cfg80211_registered_device *rdev; 1943 int err; 1944 struct net_device *dev; 1945 struct station_parameters params; 1946 u8 *mac_addr = NULL; 1947 1948 memset(¶ms, 0, sizeof(params)); 1949 1950 if (!info->attrs[NL80211_ATTR_MAC]) 1951 return -EINVAL; 1952 1953 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]) 1954 return -EINVAL; 1955 1956 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) 1957 return -EINVAL; 1958 1959 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 1960 params.supported_rates = 1961 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 1962 params.supported_rates_len = 1963 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 1964 params.listen_interval = 1965 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]); 1966 1967 if (info->attrs[NL80211_ATTR_STA_AID]) { 1968 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]); 1969 if (!params.aid || params.aid > IEEE80211_MAX_AID) 1970 return -EINVAL; 1971 } 1972 1973 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) 1974 params.ht_capa = 1975 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]); 1976 1977 if (parse_station_flags(info, ¶ms)) 1978 return -EINVAL; 1979 1980 rtnl_lock(); 1981 1982 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 1983 if (err) 1984 goto out_rtnl; 1985 1986 err = get_vlan(info, rdev, ¶ms.vlan); 1987 if (err) 1988 goto out; 1989 1990 /* validate settings */ 1991 err = 0; 1992 1993 switch (dev->ieee80211_ptr->iftype) { 1994 case NL80211_IFTYPE_AP: 1995 case NL80211_IFTYPE_AP_VLAN: 1996 /* all ok but must have AID */ 1997 if (!params.aid) 1998 err = -EINVAL; 1999 break; 2000 case NL80211_IFTYPE_MESH_POINT: 2001 /* disallow things mesh doesn't support */ 2002 if (params.vlan) 2003 err = -EINVAL; 2004 if (params.aid) 2005 err = -EINVAL; 2006 if (params.ht_capa) 2007 err = -EINVAL; 2008 if (params.listen_interval >= 0) 2009 err = -EINVAL; 2010 if (params.supported_rates) 2011 err = -EINVAL; 2012 if (params.sta_flags_mask) 2013 err = -EINVAL; 2014 break; 2015 default: 2016 err = -EINVAL; 2017 } 2018 2019 if (err) 2020 goto out; 2021 2022 if (!rdev->ops->add_station) { 2023 err = -EOPNOTSUPP; 2024 goto out; 2025 } 2026 2027 if (!netif_running(dev)) { 2028 err = -ENETDOWN; 2029 goto out; 2030 } 2031 2032 err = rdev->ops->add_station(&rdev->wiphy, dev, mac_addr, ¶ms); 2033 2034 out: 2035 if (params.vlan) 2036 dev_put(params.vlan); 2037 cfg80211_unlock_rdev(rdev); 2038 dev_put(dev); 2039 out_rtnl: 2040 rtnl_unlock(); 2041 2042 return err; 2043 } 2044 2045 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info) 2046 { 2047 struct cfg80211_registered_device *rdev; 2048 int err; 2049 struct net_device *dev; 2050 u8 *mac_addr = NULL; 2051 2052 if (info->attrs[NL80211_ATTR_MAC]) 2053 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 2054 2055 rtnl_lock(); 2056 2057 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2058 if (err) 2059 goto out_rtnl; 2060 2061 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 2062 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN && 2063 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) { 2064 err = -EINVAL; 2065 goto out; 2066 } 2067 2068 if (!rdev->ops->del_station) { 2069 err = -EOPNOTSUPP; 2070 goto out; 2071 } 2072 2073 err = rdev->ops->del_station(&rdev->wiphy, dev, mac_addr); 2074 2075 out: 2076 cfg80211_unlock_rdev(rdev); 2077 dev_put(dev); 2078 out_rtnl: 2079 rtnl_unlock(); 2080 2081 return err; 2082 } 2083 2084 static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq, 2085 int flags, struct net_device *dev, 2086 u8 *dst, u8 *next_hop, 2087 struct mpath_info *pinfo) 2088 { 2089 void *hdr; 2090 struct nlattr *pinfoattr; 2091 2092 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION); 2093 if (!hdr) 2094 return -1; 2095 2096 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex); 2097 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst); 2098 NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop); 2099 2100 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, pinfo->generation); 2101 2102 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO); 2103 if (!pinfoattr) 2104 goto nla_put_failure; 2105 if (pinfo->filled & MPATH_INFO_FRAME_QLEN) 2106 NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN, 2107 pinfo->frame_qlen); 2108 if (pinfo->filled & MPATH_INFO_DSN) 2109 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DSN, 2110 pinfo->dsn); 2111 if (pinfo->filled & MPATH_INFO_METRIC) 2112 NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC, 2113 pinfo->metric); 2114 if (pinfo->filled & MPATH_INFO_EXPTIME) 2115 NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME, 2116 pinfo->exptime); 2117 if (pinfo->filled & MPATH_INFO_FLAGS) 2118 NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS, 2119 pinfo->flags); 2120 if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) 2121 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT, 2122 pinfo->discovery_timeout); 2123 if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) 2124 NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES, 2125 pinfo->discovery_retries); 2126 2127 nla_nest_end(msg, pinfoattr); 2128 2129 return genlmsg_end(msg, hdr); 2130 2131 nla_put_failure: 2132 genlmsg_cancel(msg, hdr); 2133 return -EMSGSIZE; 2134 } 2135 2136 static int nl80211_dump_mpath(struct sk_buff *skb, 2137 struct netlink_callback *cb) 2138 { 2139 struct mpath_info pinfo; 2140 struct cfg80211_registered_device *dev; 2141 struct net_device *netdev; 2142 u8 dst[ETH_ALEN]; 2143 u8 next_hop[ETH_ALEN]; 2144 int ifidx = cb->args[0]; 2145 int path_idx = cb->args[1]; 2146 int err; 2147 2148 if (!ifidx) { 2149 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, 2150 nl80211_fam.attrbuf, nl80211_fam.maxattr, 2151 nl80211_policy); 2152 if (err) 2153 return err; 2154 2155 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]) 2156 return -EINVAL; 2157 2158 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]); 2159 if (!ifidx) 2160 return -EINVAL; 2161 } 2162 2163 rtnl_lock(); 2164 2165 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx); 2166 if (!netdev) { 2167 err = -ENODEV; 2168 goto out_rtnl; 2169 } 2170 2171 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx); 2172 if (IS_ERR(dev)) { 2173 err = PTR_ERR(dev); 2174 goto out_rtnl; 2175 } 2176 2177 if (!dev->ops->dump_mpath) { 2178 err = -EOPNOTSUPP; 2179 goto out_err; 2180 } 2181 2182 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) { 2183 err = -EOPNOTSUPP; 2184 goto out_err; 2185 } 2186 2187 while (1) { 2188 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx, 2189 dst, next_hop, &pinfo); 2190 if (err == -ENOENT) 2191 break; 2192 if (err) 2193 goto out_err; 2194 2195 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid, 2196 cb->nlh->nlmsg_seq, NLM_F_MULTI, 2197 netdev, dst, next_hop, 2198 &pinfo) < 0) 2199 goto out; 2200 2201 path_idx++; 2202 } 2203 2204 2205 out: 2206 cb->args[1] = path_idx; 2207 err = skb->len; 2208 out_err: 2209 cfg80211_unlock_rdev(dev); 2210 out_rtnl: 2211 rtnl_unlock(); 2212 2213 return err; 2214 } 2215 2216 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info) 2217 { 2218 struct cfg80211_registered_device *rdev; 2219 int err; 2220 struct net_device *dev; 2221 struct mpath_info pinfo; 2222 struct sk_buff *msg; 2223 u8 *dst = NULL; 2224 u8 next_hop[ETH_ALEN]; 2225 2226 memset(&pinfo, 0, sizeof(pinfo)); 2227 2228 if (!info->attrs[NL80211_ATTR_MAC]) 2229 return -EINVAL; 2230 2231 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 2232 2233 rtnl_lock(); 2234 2235 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2236 if (err) 2237 goto out_rtnl; 2238 2239 if (!rdev->ops->get_mpath) { 2240 err = -EOPNOTSUPP; 2241 goto out; 2242 } 2243 2244 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) { 2245 err = -EOPNOTSUPP; 2246 goto out; 2247 } 2248 2249 err = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, &pinfo); 2250 if (err) 2251 goto out; 2252 2253 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 2254 if (!msg) 2255 goto out; 2256 2257 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0, 2258 dev, dst, next_hop, &pinfo) < 0) 2259 goto out_free; 2260 2261 err = genlmsg_reply(msg, info); 2262 goto out; 2263 2264 out_free: 2265 nlmsg_free(msg); 2266 out: 2267 cfg80211_unlock_rdev(rdev); 2268 dev_put(dev); 2269 out_rtnl: 2270 rtnl_unlock(); 2271 2272 return err; 2273 } 2274 2275 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info) 2276 { 2277 struct cfg80211_registered_device *rdev; 2278 int err; 2279 struct net_device *dev; 2280 u8 *dst = NULL; 2281 u8 *next_hop = NULL; 2282 2283 if (!info->attrs[NL80211_ATTR_MAC]) 2284 return -EINVAL; 2285 2286 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]) 2287 return -EINVAL; 2288 2289 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 2290 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]); 2291 2292 rtnl_lock(); 2293 2294 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2295 if (err) 2296 goto out_rtnl; 2297 2298 if (!rdev->ops->change_mpath) { 2299 err = -EOPNOTSUPP; 2300 goto out; 2301 } 2302 2303 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) { 2304 err = -EOPNOTSUPP; 2305 goto out; 2306 } 2307 2308 if (!netif_running(dev)) { 2309 err = -ENETDOWN; 2310 goto out; 2311 } 2312 2313 err = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop); 2314 2315 out: 2316 cfg80211_unlock_rdev(rdev); 2317 dev_put(dev); 2318 out_rtnl: 2319 rtnl_unlock(); 2320 2321 return err; 2322 } 2323 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info) 2324 { 2325 struct cfg80211_registered_device *rdev; 2326 int err; 2327 struct net_device *dev; 2328 u8 *dst = NULL; 2329 u8 *next_hop = NULL; 2330 2331 if (!info->attrs[NL80211_ATTR_MAC]) 2332 return -EINVAL; 2333 2334 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]) 2335 return -EINVAL; 2336 2337 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 2338 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]); 2339 2340 rtnl_lock(); 2341 2342 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2343 if (err) 2344 goto out_rtnl; 2345 2346 if (!rdev->ops->add_mpath) { 2347 err = -EOPNOTSUPP; 2348 goto out; 2349 } 2350 2351 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) { 2352 err = -EOPNOTSUPP; 2353 goto out; 2354 } 2355 2356 if (!netif_running(dev)) { 2357 err = -ENETDOWN; 2358 goto out; 2359 } 2360 2361 err = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop); 2362 2363 out: 2364 cfg80211_unlock_rdev(rdev); 2365 dev_put(dev); 2366 out_rtnl: 2367 rtnl_unlock(); 2368 2369 return err; 2370 } 2371 2372 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info) 2373 { 2374 struct cfg80211_registered_device *rdev; 2375 int err; 2376 struct net_device *dev; 2377 u8 *dst = NULL; 2378 2379 if (info->attrs[NL80211_ATTR_MAC]) 2380 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 2381 2382 rtnl_lock(); 2383 2384 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2385 if (err) 2386 goto out_rtnl; 2387 2388 if (!rdev->ops->del_mpath) { 2389 err = -EOPNOTSUPP; 2390 goto out; 2391 } 2392 2393 err = rdev->ops->del_mpath(&rdev->wiphy, dev, dst); 2394 2395 out: 2396 cfg80211_unlock_rdev(rdev); 2397 dev_put(dev); 2398 out_rtnl: 2399 rtnl_unlock(); 2400 2401 return err; 2402 } 2403 2404 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info) 2405 { 2406 struct cfg80211_registered_device *rdev; 2407 int err; 2408 struct net_device *dev; 2409 struct bss_parameters params; 2410 2411 memset(¶ms, 0, sizeof(params)); 2412 /* default to not changing parameters */ 2413 params.use_cts_prot = -1; 2414 params.use_short_preamble = -1; 2415 params.use_short_slot_time = -1; 2416 2417 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT]) 2418 params.use_cts_prot = 2419 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]); 2420 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]) 2421 params.use_short_preamble = 2422 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]); 2423 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]) 2424 params.use_short_slot_time = 2425 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]); 2426 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) { 2427 params.basic_rates = 2428 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 2429 params.basic_rates_len = 2430 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 2431 } 2432 2433 rtnl_lock(); 2434 2435 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2436 if (err) 2437 goto out_rtnl; 2438 2439 if (!rdev->ops->change_bss) { 2440 err = -EOPNOTSUPP; 2441 goto out; 2442 } 2443 2444 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) { 2445 err = -EOPNOTSUPP; 2446 goto out; 2447 } 2448 2449 err = rdev->ops->change_bss(&rdev->wiphy, dev, ¶ms); 2450 2451 out: 2452 cfg80211_unlock_rdev(rdev); 2453 dev_put(dev); 2454 out_rtnl: 2455 rtnl_unlock(); 2456 2457 return err; 2458 } 2459 2460 static const struct nla_policy 2461 reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = { 2462 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 }, 2463 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 }, 2464 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 }, 2465 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 }, 2466 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 }, 2467 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 }, 2468 }; 2469 2470 static int parse_reg_rule(struct nlattr *tb[], 2471 struct ieee80211_reg_rule *reg_rule) 2472 { 2473 struct ieee80211_freq_range *freq_range = ®_rule->freq_range; 2474 struct ieee80211_power_rule *power_rule = ®_rule->power_rule; 2475 2476 if (!tb[NL80211_ATTR_REG_RULE_FLAGS]) 2477 return -EINVAL; 2478 if (!tb[NL80211_ATTR_FREQ_RANGE_START]) 2479 return -EINVAL; 2480 if (!tb[NL80211_ATTR_FREQ_RANGE_END]) 2481 return -EINVAL; 2482 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) 2483 return -EINVAL; 2484 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]) 2485 return -EINVAL; 2486 2487 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]); 2488 2489 freq_range->start_freq_khz = 2490 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]); 2491 freq_range->end_freq_khz = 2492 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]); 2493 freq_range->max_bandwidth_khz = 2494 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]); 2495 2496 power_rule->max_eirp = 2497 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]); 2498 2499 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]) 2500 power_rule->max_antenna_gain = 2501 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]); 2502 2503 return 0; 2504 } 2505 2506 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info) 2507 { 2508 int r; 2509 char *data = NULL; 2510 2511 /* 2512 * You should only get this when cfg80211 hasn't yet initialized 2513 * completely when built-in to the kernel right between the time 2514 * window between nl80211_init() and regulatory_init(), if that is 2515 * even possible. 2516 */ 2517 mutex_lock(&cfg80211_mutex); 2518 if (unlikely(!cfg80211_regdomain)) { 2519 mutex_unlock(&cfg80211_mutex); 2520 return -EINPROGRESS; 2521 } 2522 mutex_unlock(&cfg80211_mutex); 2523 2524 if (!info->attrs[NL80211_ATTR_REG_ALPHA2]) 2525 return -EINVAL; 2526 2527 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]); 2528 2529 #ifdef CONFIG_WIRELESS_OLD_REGULATORY 2530 /* We ignore world regdom requests with the old regdom setup */ 2531 if (is_world_regdom(data)) 2532 return -EINVAL; 2533 #endif 2534 2535 r = regulatory_hint_user(data); 2536 2537 return r; 2538 } 2539 2540 static int nl80211_get_mesh_params(struct sk_buff *skb, 2541 struct genl_info *info) 2542 { 2543 struct cfg80211_registered_device *rdev; 2544 struct mesh_config cur_params; 2545 int err; 2546 struct net_device *dev; 2547 void *hdr; 2548 struct nlattr *pinfoattr; 2549 struct sk_buff *msg; 2550 2551 rtnl_lock(); 2552 2553 /* Look up our device */ 2554 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2555 if (err) 2556 goto out_rtnl; 2557 2558 if (!rdev->ops->get_mesh_params) { 2559 err = -EOPNOTSUPP; 2560 goto out; 2561 } 2562 2563 /* Get the mesh params */ 2564 err = rdev->ops->get_mesh_params(&rdev->wiphy, dev, &cur_params); 2565 if (err) 2566 goto out; 2567 2568 /* Draw up a netlink message to send back */ 2569 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 2570 if (!msg) { 2571 err = -ENOBUFS; 2572 goto out; 2573 } 2574 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0, 2575 NL80211_CMD_GET_MESH_PARAMS); 2576 if (!hdr) 2577 goto nla_put_failure; 2578 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS); 2579 if (!pinfoattr) 2580 goto nla_put_failure; 2581 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex); 2582 NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, 2583 cur_params.dot11MeshRetryTimeout); 2584 NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, 2585 cur_params.dot11MeshConfirmTimeout); 2586 NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, 2587 cur_params.dot11MeshHoldingTimeout); 2588 NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, 2589 cur_params.dot11MeshMaxPeerLinks); 2590 NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES, 2591 cur_params.dot11MeshMaxRetries); 2592 NLA_PUT_U8(msg, NL80211_MESHCONF_TTL, 2593 cur_params.dot11MeshTTL); 2594 NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, 2595 cur_params.auto_open_plinks); 2596 NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, 2597 cur_params.dot11MeshHWMPmaxPREQretries); 2598 NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, 2599 cur_params.path_refresh_time); 2600 NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, 2601 cur_params.min_discovery_timeout); 2602 NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, 2603 cur_params.dot11MeshHWMPactivePathTimeout); 2604 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, 2605 cur_params.dot11MeshHWMPpreqMinInterval); 2606 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, 2607 cur_params.dot11MeshHWMPnetDiameterTraversalTime); 2608 nla_nest_end(msg, pinfoattr); 2609 genlmsg_end(msg, hdr); 2610 err = genlmsg_reply(msg, info); 2611 goto out; 2612 2613 nla_put_failure: 2614 genlmsg_cancel(msg, hdr); 2615 err = -EMSGSIZE; 2616 out: 2617 /* Cleanup */ 2618 cfg80211_unlock_rdev(rdev); 2619 dev_put(dev); 2620 out_rtnl: 2621 rtnl_unlock(); 2622 2623 return err; 2624 } 2625 2626 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \ 2627 do {\ 2628 if (table[attr_num]) {\ 2629 cfg.param = nla_fn(table[attr_num]); \ 2630 mask |= (1 << (attr_num - 1)); \ 2631 } \ 2632 } while (0);\ 2633 2634 static struct nla_policy 2635 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] __read_mostly = { 2636 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 }, 2637 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 }, 2638 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 }, 2639 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 }, 2640 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 }, 2641 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 }, 2642 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 }, 2643 2644 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 }, 2645 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 }, 2646 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 }, 2647 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 }, 2648 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 }, 2649 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 }, 2650 }; 2651 2652 static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info) 2653 { 2654 int err; 2655 u32 mask; 2656 struct cfg80211_registered_device *rdev; 2657 struct net_device *dev; 2658 struct mesh_config cfg; 2659 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1]; 2660 struct nlattr *parent_attr; 2661 2662 parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS]; 2663 if (!parent_attr) 2664 return -EINVAL; 2665 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX, 2666 parent_attr, nl80211_meshconf_params_policy)) 2667 return -EINVAL; 2668 2669 rtnl_lock(); 2670 2671 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2672 if (err) 2673 goto out_rtnl; 2674 2675 if (!rdev->ops->set_mesh_params) { 2676 err = -EOPNOTSUPP; 2677 goto out; 2678 } 2679 2680 /* This makes sure that there aren't more than 32 mesh config 2681 * parameters (otherwise our bitfield scheme would not work.) */ 2682 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32); 2683 2684 /* Fill in the params struct */ 2685 mask = 0; 2686 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 2687 mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16); 2688 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 2689 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16); 2690 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 2691 mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16); 2692 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 2693 mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16); 2694 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 2695 mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8); 2696 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 2697 mask, NL80211_MESHCONF_TTL, nla_get_u8); 2698 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 2699 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8); 2700 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 2701 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, 2702 nla_get_u8); 2703 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 2704 mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32); 2705 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 2706 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, 2707 nla_get_u16); 2708 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout, 2709 mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, 2710 nla_get_u32); 2711 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval, 2712 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, 2713 nla_get_u16); 2714 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, 2715 dot11MeshHWMPnetDiameterTraversalTime, 2716 mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, 2717 nla_get_u16); 2718 2719 /* Apply changes */ 2720 err = rdev->ops->set_mesh_params(&rdev->wiphy, dev, &cfg, mask); 2721 2722 out: 2723 /* cleanup */ 2724 cfg80211_unlock_rdev(rdev); 2725 dev_put(dev); 2726 out_rtnl: 2727 rtnl_unlock(); 2728 2729 return err; 2730 } 2731 2732 #undef FILL_IN_MESH_PARAM_IF_SET 2733 2734 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info) 2735 { 2736 struct sk_buff *msg; 2737 void *hdr = NULL; 2738 struct nlattr *nl_reg_rules; 2739 unsigned int i; 2740 int err = -EINVAL; 2741 2742 mutex_lock(&cfg80211_mutex); 2743 2744 if (!cfg80211_regdomain) 2745 goto out; 2746 2747 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 2748 if (!msg) { 2749 err = -ENOBUFS; 2750 goto out; 2751 } 2752 2753 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0, 2754 NL80211_CMD_GET_REG); 2755 if (!hdr) 2756 goto nla_put_failure; 2757 2758 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, 2759 cfg80211_regdomain->alpha2); 2760 2761 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES); 2762 if (!nl_reg_rules) 2763 goto nla_put_failure; 2764 2765 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) { 2766 struct nlattr *nl_reg_rule; 2767 const struct ieee80211_reg_rule *reg_rule; 2768 const struct ieee80211_freq_range *freq_range; 2769 const struct ieee80211_power_rule *power_rule; 2770 2771 reg_rule = &cfg80211_regdomain->reg_rules[i]; 2772 freq_range = ®_rule->freq_range; 2773 power_rule = ®_rule->power_rule; 2774 2775 nl_reg_rule = nla_nest_start(msg, i); 2776 if (!nl_reg_rule) 2777 goto nla_put_failure; 2778 2779 NLA_PUT_U32(msg, NL80211_ATTR_REG_RULE_FLAGS, 2780 reg_rule->flags); 2781 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_START, 2782 freq_range->start_freq_khz); 2783 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_END, 2784 freq_range->end_freq_khz); 2785 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW, 2786 freq_range->max_bandwidth_khz); 2787 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN, 2788 power_rule->max_antenna_gain); 2789 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP, 2790 power_rule->max_eirp); 2791 2792 nla_nest_end(msg, nl_reg_rule); 2793 } 2794 2795 nla_nest_end(msg, nl_reg_rules); 2796 2797 genlmsg_end(msg, hdr); 2798 err = genlmsg_reply(msg, info); 2799 goto out; 2800 2801 nla_put_failure: 2802 genlmsg_cancel(msg, hdr); 2803 err = -EMSGSIZE; 2804 out: 2805 mutex_unlock(&cfg80211_mutex); 2806 return err; 2807 } 2808 2809 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info) 2810 { 2811 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1]; 2812 struct nlattr *nl_reg_rule; 2813 char *alpha2 = NULL; 2814 int rem_reg_rules = 0, r = 0; 2815 u32 num_rules = 0, rule_idx = 0, size_of_regd; 2816 struct ieee80211_regdomain *rd = NULL; 2817 2818 if (!info->attrs[NL80211_ATTR_REG_ALPHA2]) 2819 return -EINVAL; 2820 2821 if (!info->attrs[NL80211_ATTR_REG_RULES]) 2822 return -EINVAL; 2823 2824 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]); 2825 2826 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES], 2827 rem_reg_rules) { 2828 num_rules++; 2829 if (num_rules > NL80211_MAX_SUPP_REG_RULES) 2830 return -EINVAL; 2831 } 2832 2833 mutex_lock(&cfg80211_mutex); 2834 2835 if (!reg_is_valid_request(alpha2)) { 2836 r = -EINVAL; 2837 goto bad_reg; 2838 } 2839 2840 size_of_regd = sizeof(struct ieee80211_regdomain) + 2841 (num_rules * sizeof(struct ieee80211_reg_rule)); 2842 2843 rd = kzalloc(size_of_regd, GFP_KERNEL); 2844 if (!rd) { 2845 r = -ENOMEM; 2846 goto bad_reg; 2847 } 2848 2849 rd->n_reg_rules = num_rules; 2850 rd->alpha2[0] = alpha2[0]; 2851 rd->alpha2[1] = alpha2[1]; 2852 2853 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES], 2854 rem_reg_rules) { 2855 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX, 2856 nla_data(nl_reg_rule), nla_len(nl_reg_rule), 2857 reg_rule_policy); 2858 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]); 2859 if (r) 2860 goto bad_reg; 2861 2862 rule_idx++; 2863 2864 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) { 2865 r = -EINVAL; 2866 goto bad_reg; 2867 } 2868 } 2869 2870 BUG_ON(rule_idx != num_rules); 2871 2872 r = set_regdom(rd); 2873 2874 mutex_unlock(&cfg80211_mutex); 2875 2876 return r; 2877 2878 bad_reg: 2879 mutex_unlock(&cfg80211_mutex); 2880 kfree(rd); 2881 return r; 2882 } 2883 2884 static int validate_scan_freqs(struct nlattr *freqs) 2885 { 2886 struct nlattr *attr1, *attr2; 2887 int n_channels = 0, tmp1, tmp2; 2888 2889 nla_for_each_nested(attr1, freqs, tmp1) { 2890 n_channels++; 2891 /* 2892 * Some hardware has a limited channel list for 2893 * scanning, and it is pretty much nonsensical 2894 * to scan for a channel twice, so disallow that 2895 * and don't require drivers to check that the 2896 * channel list they get isn't longer than what 2897 * they can scan, as long as they can scan all 2898 * the channels they registered at once. 2899 */ 2900 nla_for_each_nested(attr2, freqs, tmp2) 2901 if (attr1 != attr2 && 2902 nla_get_u32(attr1) == nla_get_u32(attr2)) 2903 return 0; 2904 } 2905 2906 return n_channels; 2907 } 2908 2909 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info) 2910 { 2911 struct cfg80211_registered_device *rdev; 2912 struct net_device *dev; 2913 struct cfg80211_scan_request *request; 2914 struct cfg80211_ssid *ssid; 2915 struct ieee80211_channel *channel; 2916 struct nlattr *attr; 2917 struct wiphy *wiphy; 2918 int err, tmp, n_ssids = 0, n_channels, i; 2919 enum ieee80211_band band; 2920 size_t ie_len; 2921 2922 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) 2923 return -EINVAL; 2924 2925 rtnl_lock(); 2926 2927 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 2928 if (err) 2929 goto out_rtnl; 2930 2931 wiphy = &rdev->wiphy; 2932 2933 if (!rdev->ops->scan) { 2934 err = -EOPNOTSUPP; 2935 goto out; 2936 } 2937 2938 if (!netif_running(dev)) { 2939 err = -ENETDOWN; 2940 goto out; 2941 } 2942 2943 if (rdev->scan_req) { 2944 err = -EBUSY; 2945 goto out; 2946 } 2947 2948 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) { 2949 n_channels = validate_scan_freqs( 2950 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]); 2951 if (!n_channels) { 2952 err = -EINVAL; 2953 goto out; 2954 } 2955 } else { 2956 n_channels = 0; 2957 2958 for (band = 0; band < IEEE80211_NUM_BANDS; band++) 2959 if (wiphy->bands[band]) 2960 n_channels += wiphy->bands[band]->n_channels; 2961 } 2962 2963 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) 2964 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) 2965 n_ssids++; 2966 2967 if (n_ssids > wiphy->max_scan_ssids) { 2968 err = -EINVAL; 2969 goto out; 2970 } 2971 2972 if (info->attrs[NL80211_ATTR_IE]) 2973 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 2974 else 2975 ie_len = 0; 2976 2977 if (ie_len > wiphy->max_scan_ie_len) { 2978 err = -EINVAL; 2979 goto out; 2980 } 2981 2982 request = kzalloc(sizeof(*request) 2983 + sizeof(*ssid) * n_ssids 2984 + sizeof(channel) * n_channels 2985 + ie_len, GFP_KERNEL); 2986 if (!request) { 2987 err = -ENOMEM; 2988 goto out; 2989 } 2990 2991 request->n_channels = n_channels; 2992 if (n_ssids) 2993 request->ssids = (void *)&request->channels[n_channels]; 2994 request->n_ssids = n_ssids; 2995 if (ie_len) { 2996 if (request->ssids) 2997 request->ie = (void *)(request->ssids + n_ssids); 2998 else 2999 request->ie = (void *)(request->channels + n_channels); 3000 } 3001 3002 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) { 3003 /* user specified, bail out if channel not found */ 3004 request->n_channels = n_channels; 3005 i = 0; 3006 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) { 3007 request->channels[i] = ieee80211_get_channel(wiphy, nla_get_u32(attr)); 3008 if (!request->channels[i]) { 3009 err = -EINVAL; 3010 goto out_free; 3011 } 3012 i++; 3013 } 3014 } else { 3015 /* all channels */ 3016 i = 0; 3017 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 3018 int j; 3019 if (!wiphy->bands[band]) 3020 continue; 3021 for (j = 0; j < wiphy->bands[band]->n_channels; j++) { 3022 request->channels[i] = &wiphy->bands[band]->channels[j]; 3023 i++; 3024 } 3025 } 3026 } 3027 3028 i = 0; 3029 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) { 3030 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) { 3031 if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) { 3032 err = -EINVAL; 3033 goto out_free; 3034 } 3035 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr)); 3036 request->ssids[i].ssid_len = nla_len(attr); 3037 i++; 3038 } 3039 } 3040 3041 if (info->attrs[NL80211_ATTR_IE]) { 3042 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 3043 memcpy((void *)request->ie, 3044 nla_data(info->attrs[NL80211_ATTR_IE]), 3045 request->ie_len); 3046 } 3047 3048 request->dev = dev; 3049 request->wiphy = &rdev->wiphy; 3050 3051 rdev->scan_req = request; 3052 err = rdev->ops->scan(&rdev->wiphy, dev, request); 3053 3054 if (!err) { 3055 nl80211_send_scan_start(rdev, dev); 3056 dev_hold(dev); 3057 } 3058 3059 out_free: 3060 if (err) { 3061 rdev->scan_req = NULL; 3062 kfree(request); 3063 } 3064 out: 3065 cfg80211_unlock_rdev(rdev); 3066 dev_put(dev); 3067 out_rtnl: 3068 rtnl_unlock(); 3069 3070 return err; 3071 } 3072 3073 static int nl80211_send_bss(struct sk_buff *msg, u32 pid, u32 seq, int flags, 3074 struct cfg80211_registered_device *rdev, 3075 struct wireless_dev *wdev, 3076 struct cfg80211_internal_bss *intbss) 3077 { 3078 struct cfg80211_bss *res = &intbss->pub; 3079 void *hdr; 3080 struct nlattr *bss; 3081 int i; 3082 3083 ASSERT_WDEV_LOCK(wdev); 3084 3085 hdr = nl80211hdr_put(msg, pid, seq, flags, 3086 NL80211_CMD_NEW_SCAN_RESULTS); 3087 if (!hdr) 3088 return -1; 3089 3090 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation); 3091 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex); 3092 3093 bss = nla_nest_start(msg, NL80211_ATTR_BSS); 3094 if (!bss) 3095 goto nla_put_failure; 3096 if (!is_zero_ether_addr(res->bssid)) 3097 NLA_PUT(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid); 3098 if (res->information_elements && res->len_information_elements) 3099 NLA_PUT(msg, NL80211_BSS_INFORMATION_ELEMENTS, 3100 res->len_information_elements, 3101 res->information_elements); 3102 if (res->tsf) 3103 NLA_PUT_U64(msg, NL80211_BSS_TSF, res->tsf); 3104 if (res->beacon_interval) 3105 NLA_PUT_U16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval); 3106 NLA_PUT_U16(msg, NL80211_BSS_CAPABILITY, res->capability); 3107 NLA_PUT_U32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq); 3108 3109 switch (rdev->wiphy.signal_type) { 3110 case CFG80211_SIGNAL_TYPE_MBM: 3111 NLA_PUT_U32(msg, NL80211_BSS_SIGNAL_MBM, res->signal); 3112 break; 3113 case CFG80211_SIGNAL_TYPE_UNSPEC: 3114 NLA_PUT_U8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal); 3115 break; 3116 default: 3117 break; 3118 } 3119 3120 switch (wdev->iftype) { 3121 case NL80211_IFTYPE_STATION: 3122 if (intbss == wdev->current_bss) 3123 NLA_PUT_U32(msg, NL80211_BSS_STATUS, 3124 NL80211_BSS_STATUS_ASSOCIATED); 3125 else for (i = 0; i < MAX_AUTH_BSSES; i++) { 3126 if (intbss != wdev->auth_bsses[i]) 3127 continue; 3128 NLA_PUT_U32(msg, NL80211_BSS_STATUS, 3129 NL80211_BSS_STATUS_AUTHENTICATED); 3130 break; 3131 } 3132 break; 3133 case NL80211_IFTYPE_ADHOC: 3134 if (intbss == wdev->current_bss) 3135 NLA_PUT_U32(msg, NL80211_BSS_STATUS, 3136 NL80211_BSS_STATUS_IBSS_JOINED); 3137 break; 3138 default: 3139 break; 3140 } 3141 3142 nla_nest_end(msg, bss); 3143 3144 return genlmsg_end(msg, hdr); 3145 3146 nla_put_failure: 3147 genlmsg_cancel(msg, hdr); 3148 return -EMSGSIZE; 3149 } 3150 3151 static int nl80211_dump_scan(struct sk_buff *skb, 3152 struct netlink_callback *cb) 3153 { 3154 struct cfg80211_registered_device *rdev; 3155 struct net_device *dev; 3156 struct cfg80211_internal_bss *scan; 3157 struct wireless_dev *wdev; 3158 int ifidx = cb->args[0]; 3159 int start = cb->args[1], idx = 0; 3160 int err; 3161 3162 if (!ifidx) { 3163 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, 3164 nl80211_fam.attrbuf, nl80211_fam.maxattr, 3165 nl80211_policy); 3166 if (err) 3167 return err; 3168 3169 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]) 3170 return -EINVAL; 3171 3172 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]); 3173 if (!ifidx) 3174 return -EINVAL; 3175 cb->args[0] = ifidx; 3176 } 3177 3178 dev = dev_get_by_index(sock_net(skb->sk), ifidx); 3179 if (!dev) 3180 return -ENODEV; 3181 3182 rdev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx); 3183 if (IS_ERR(rdev)) { 3184 err = PTR_ERR(rdev); 3185 goto out_put_netdev; 3186 } 3187 3188 wdev = dev->ieee80211_ptr; 3189 3190 wdev_lock(wdev); 3191 spin_lock_bh(&rdev->bss_lock); 3192 cfg80211_bss_expire(rdev); 3193 3194 list_for_each_entry(scan, &rdev->bss_list, list) { 3195 if (++idx <= start) 3196 continue; 3197 if (nl80211_send_bss(skb, 3198 NETLINK_CB(cb->skb).pid, 3199 cb->nlh->nlmsg_seq, NLM_F_MULTI, 3200 rdev, wdev, scan) < 0) { 3201 idx--; 3202 goto out; 3203 } 3204 } 3205 3206 out: 3207 spin_unlock_bh(&rdev->bss_lock); 3208 wdev_unlock(wdev); 3209 3210 cb->args[1] = idx; 3211 err = skb->len; 3212 cfg80211_unlock_rdev(rdev); 3213 out_put_netdev: 3214 dev_put(dev); 3215 3216 return err; 3217 } 3218 3219 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type) 3220 { 3221 return auth_type <= NL80211_AUTHTYPE_MAX; 3222 } 3223 3224 static bool nl80211_valid_wpa_versions(u32 wpa_versions) 3225 { 3226 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 | 3227 NL80211_WPA_VERSION_2)); 3228 } 3229 3230 static bool nl80211_valid_akm_suite(u32 akm) 3231 { 3232 return akm == WLAN_AKM_SUITE_8021X || 3233 akm == WLAN_AKM_SUITE_PSK; 3234 } 3235 3236 static bool nl80211_valid_cipher_suite(u32 cipher) 3237 { 3238 return cipher == WLAN_CIPHER_SUITE_WEP40 || 3239 cipher == WLAN_CIPHER_SUITE_WEP104 || 3240 cipher == WLAN_CIPHER_SUITE_TKIP || 3241 cipher == WLAN_CIPHER_SUITE_CCMP || 3242 cipher == WLAN_CIPHER_SUITE_AES_CMAC; 3243 } 3244 3245 3246 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info) 3247 { 3248 struct cfg80211_registered_device *rdev; 3249 struct net_device *dev; 3250 struct ieee80211_channel *chan; 3251 const u8 *bssid, *ssid, *ie = NULL; 3252 int err, ssid_len, ie_len = 0; 3253 enum nl80211_auth_type auth_type; 3254 struct key_parse key; 3255 3256 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) 3257 return -EINVAL; 3258 3259 if (!info->attrs[NL80211_ATTR_MAC]) 3260 return -EINVAL; 3261 3262 if (!info->attrs[NL80211_ATTR_AUTH_TYPE]) 3263 return -EINVAL; 3264 3265 if (!info->attrs[NL80211_ATTR_SSID]) 3266 return -EINVAL; 3267 3268 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ]) 3269 return -EINVAL; 3270 3271 err = nl80211_parse_key(info, &key); 3272 if (err) 3273 return err; 3274 3275 if (key.idx >= 0) { 3276 if (!key.p.key || !key.p.key_len) 3277 return -EINVAL; 3278 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 || 3279 key.p.key_len != WLAN_KEY_LEN_WEP40) && 3280 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 || 3281 key.p.key_len != WLAN_KEY_LEN_WEP104)) 3282 return -EINVAL; 3283 if (key.idx > 4) 3284 return -EINVAL; 3285 } else { 3286 key.p.key_len = 0; 3287 key.p.key = NULL; 3288 } 3289 3290 rtnl_lock(); 3291 3292 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3293 if (err) 3294 goto unlock_rtnl; 3295 3296 if (!rdev->ops->auth) { 3297 err = -EOPNOTSUPP; 3298 goto out; 3299 } 3300 3301 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) { 3302 err = -EOPNOTSUPP; 3303 goto out; 3304 } 3305 3306 if (!netif_running(dev)) { 3307 err = -ENETDOWN; 3308 goto out; 3309 } 3310 3311 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 3312 chan = ieee80211_get_channel(&rdev->wiphy, 3313 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ])); 3314 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) { 3315 err = -EINVAL; 3316 goto out; 3317 } 3318 3319 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 3320 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 3321 3322 if (info->attrs[NL80211_ATTR_IE]) { 3323 ie = nla_data(info->attrs[NL80211_ATTR_IE]); 3324 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 3325 } 3326 3327 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]); 3328 if (!nl80211_valid_auth_type(auth_type)) { 3329 err = -EINVAL; 3330 goto out; 3331 } 3332 3333 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid, 3334 ssid, ssid_len, ie, ie_len, 3335 key.p.key, key.p.key_len, key.idx); 3336 3337 out: 3338 cfg80211_unlock_rdev(rdev); 3339 dev_put(dev); 3340 unlock_rtnl: 3341 rtnl_unlock(); 3342 return err; 3343 } 3344 3345 static int nl80211_crypto_settings(struct genl_info *info, 3346 struct cfg80211_crypto_settings *settings, 3347 int cipher_limit) 3348 { 3349 memset(settings, 0, sizeof(*settings)); 3350 3351 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT]; 3352 3353 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) { 3354 void *data; 3355 int len, i; 3356 3357 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]); 3358 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]); 3359 settings->n_ciphers_pairwise = len / sizeof(u32); 3360 3361 if (len % sizeof(u32)) 3362 return -EINVAL; 3363 3364 if (settings->n_ciphers_pairwise > cipher_limit) 3365 return -EINVAL; 3366 3367 memcpy(settings->ciphers_pairwise, data, len); 3368 3369 for (i = 0; i < settings->n_ciphers_pairwise; i++) 3370 if (!nl80211_valid_cipher_suite( 3371 settings->ciphers_pairwise[i])) 3372 return -EINVAL; 3373 } 3374 3375 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) { 3376 settings->cipher_group = 3377 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]); 3378 if (!nl80211_valid_cipher_suite(settings->cipher_group)) 3379 return -EINVAL; 3380 } 3381 3382 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) { 3383 settings->wpa_versions = 3384 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]); 3385 if (!nl80211_valid_wpa_versions(settings->wpa_versions)) 3386 return -EINVAL; 3387 } 3388 3389 if (info->attrs[NL80211_ATTR_AKM_SUITES]) { 3390 void *data; 3391 int len, i; 3392 3393 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]); 3394 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]); 3395 settings->n_akm_suites = len / sizeof(u32); 3396 3397 if (len % sizeof(u32)) 3398 return -EINVAL; 3399 3400 memcpy(settings->akm_suites, data, len); 3401 3402 for (i = 0; i < settings->n_ciphers_pairwise; i++) 3403 if (!nl80211_valid_akm_suite(settings->akm_suites[i])) 3404 return -EINVAL; 3405 } 3406 3407 return 0; 3408 } 3409 3410 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info) 3411 { 3412 struct cfg80211_registered_device *rdev; 3413 struct net_device *dev; 3414 struct cfg80211_crypto_settings crypto; 3415 struct ieee80211_channel *chan, *fixedchan; 3416 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL; 3417 int err, ssid_len, ie_len = 0; 3418 bool use_mfp = false; 3419 3420 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) 3421 return -EINVAL; 3422 3423 if (!info->attrs[NL80211_ATTR_MAC] || 3424 !info->attrs[NL80211_ATTR_SSID] || 3425 !info->attrs[NL80211_ATTR_WIPHY_FREQ]) 3426 return -EINVAL; 3427 3428 rtnl_lock(); 3429 3430 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3431 if (err) 3432 goto unlock_rtnl; 3433 3434 if (!rdev->ops->assoc) { 3435 err = -EOPNOTSUPP; 3436 goto out; 3437 } 3438 3439 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) { 3440 err = -EOPNOTSUPP; 3441 goto out; 3442 } 3443 3444 if (!netif_running(dev)) { 3445 err = -ENETDOWN; 3446 goto out; 3447 } 3448 3449 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 3450 3451 chan = ieee80211_get_channel(&rdev->wiphy, 3452 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ])); 3453 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) { 3454 err = -EINVAL; 3455 goto out; 3456 } 3457 3458 mutex_lock(&rdev->devlist_mtx); 3459 fixedchan = rdev_fixed_channel(rdev, NULL); 3460 if (fixedchan && chan != fixedchan) { 3461 err = -EBUSY; 3462 mutex_unlock(&rdev->devlist_mtx); 3463 goto out; 3464 } 3465 mutex_unlock(&rdev->devlist_mtx); 3466 3467 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 3468 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 3469 3470 if (info->attrs[NL80211_ATTR_IE]) { 3471 ie = nla_data(info->attrs[NL80211_ATTR_IE]); 3472 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 3473 } 3474 3475 if (info->attrs[NL80211_ATTR_USE_MFP]) { 3476 enum nl80211_mfp mfp = 3477 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]); 3478 if (mfp == NL80211_MFP_REQUIRED) 3479 use_mfp = true; 3480 else if (mfp != NL80211_MFP_NO) { 3481 err = -EINVAL; 3482 goto out; 3483 } 3484 } 3485 3486 if (info->attrs[NL80211_ATTR_PREV_BSSID]) 3487 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]); 3488 3489 err = nl80211_crypto_settings(info, &crypto, 1); 3490 if (!err) 3491 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid, 3492 ssid, ssid_len, ie, ie_len, use_mfp, 3493 &crypto); 3494 3495 out: 3496 cfg80211_unlock_rdev(rdev); 3497 dev_put(dev); 3498 unlock_rtnl: 3499 rtnl_unlock(); 3500 return err; 3501 } 3502 3503 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info) 3504 { 3505 struct cfg80211_registered_device *rdev; 3506 struct net_device *dev; 3507 const u8 *ie = NULL, *bssid; 3508 int err, ie_len = 0; 3509 u16 reason_code; 3510 3511 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) 3512 return -EINVAL; 3513 3514 if (!info->attrs[NL80211_ATTR_MAC]) 3515 return -EINVAL; 3516 3517 if (!info->attrs[NL80211_ATTR_REASON_CODE]) 3518 return -EINVAL; 3519 3520 rtnl_lock(); 3521 3522 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3523 if (err) 3524 goto unlock_rtnl; 3525 3526 if (!rdev->ops->deauth) { 3527 err = -EOPNOTSUPP; 3528 goto out; 3529 } 3530 3531 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) { 3532 err = -EOPNOTSUPP; 3533 goto out; 3534 } 3535 3536 if (!netif_running(dev)) { 3537 err = -ENETDOWN; 3538 goto out; 3539 } 3540 3541 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 3542 3543 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]); 3544 if (reason_code == 0) { 3545 /* Reason Code 0 is reserved */ 3546 err = -EINVAL; 3547 goto out; 3548 } 3549 3550 if (info->attrs[NL80211_ATTR_IE]) { 3551 ie = nla_data(info->attrs[NL80211_ATTR_IE]); 3552 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 3553 } 3554 3555 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code); 3556 3557 out: 3558 cfg80211_unlock_rdev(rdev); 3559 dev_put(dev); 3560 unlock_rtnl: 3561 rtnl_unlock(); 3562 return err; 3563 } 3564 3565 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info) 3566 { 3567 struct cfg80211_registered_device *rdev; 3568 struct net_device *dev; 3569 const u8 *ie = NULL, *bssid; 3570 int err, ie_len = 0; 3571 u16 reason_code; 3572 3573 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) 3574 return -EINVAL; 3575 3576 if (!info->attrs[NL80211_ATTR_MAC]) 3577 return -EINVAL; 3578 3579 if (!info->attrs[NL80211_ATTR_REASON_CODE]) 3580 return -EINVAL; 3581 3582 rtnl_lock(); 3583 3584 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3585 if (err) 3586 goto unlock_rtnl; 3587 3588 if (!rdev->ops->disassoc) { 3589 err = -EOPNOTSUPP; 3590 goto out; 3591 } 3592 3593 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) { 3594 err = -EOPNOTSUPP; 3595 goto out; 3596 } 3597 3598 if (!netif_running(dev)) { 3599 err = -ENETDOWN; 3600 goto out; 3601 } 3602 3603 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 3604 3605 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]); 3606 if (reason_code == 0) { 3607 /* Reason Code 0 is reserved */ 3608 err = -EINVAL; 3609 goto out; 3610 } 3611 3612 if (info->attrs[NL80211_ATTR_IE]) { 3613 ie = nla_data(info->attrs[NL80211_ATTR_IE]); 3614 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 3615 } 3616 3617 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code); 3618 3619 out: 3620 cfg80211_unlock_rdev(rdev); 3621 dev_put(dev); 3622 unlock_rtnl: 3623 rtnl_unlock(); 3624 return err; 3625 } 3626 3627 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info) 3628 { 3629 struct cfg80211_registered_device *rdev; 3630 struct net_device *dev; 3631 struct cfg80211_ibss_params ibss; 3632 struct wiphy *wiphy; 3633 struct cfg80211_cached_keys *connkeys = NULL; 3634 int err; 3635 3636 memset(&ibss, 0, sizeof(ibss)); 3637 3638 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) 3639 return -EINVAL; 3640 3641 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] || 3642 !info->attrs[NL80211_ATTR_SSID] || 3643 !nla_len(info->attrs[NL80211_ATTR_SSID])) 3644 return -EINVAL; 3645 3646 ibss.beacon_interval = 100; 3647 3648 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) { 3649 ibss.beacon_interval = 3650 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]); 3651 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000) 3652 return -EINVAL; 3653 } 3654 3655 rtnl_lock(); 3656 3657 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3658 if (err) 3659 goto unlock_rtnl; 3660 3661 if (!rdev->ops->join_ibss) { 3662 err = -EOPNOTSUPP; 3663 goto out; 3664 } 3665 3666 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) { 3667 err = -EOPNOTSUPP; 3668 goto out; 3669 } 3670 3671 if (!netif_running(dev)) { 3672 err = -ENETDOWN; 3673 goto out; 3674 } 3675 3676 wiphy = &rdev->wiphy; 3677 3678 if (info->attrs[NL80211_ATTR_MAC]) 3679 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 3680 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 3681 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 3682 3683 if (info->attrs[NL80211_ATTR_IE]) { 3684 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 3685 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 3686 } 3687 3688 ibss.channel = ieee80211_get_channel(wiphy, 3689 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ])); 3690 if (!ibss.channel || 3691 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS || 3692 ibss.channel->flags & IEEE80211_CHAN_DISABLED) { 3693 err = -EINVAL; 3694 goto out; 3695 } 3696 3697 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED]; 3698 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY]; 3699 3700 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) { 3701 connkeys = nl80211_parse_connkeys(rdev, 3702 info->attrs[NL80211_ATTR_KEYS]); 3703 if (IS_ERR(connkeys)) { 3704 err = PTR_ERR(connkeys); 3705 connkeys = NULL; 3706 goto out; 3707 } 3708 } 3709 3710 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys); 3711 3712 out: 3713 cfg80211_unlock_rdev(rdev); 3714 dev_put(dev); 3715 unlock_rtnl: 3716 if (err) 3717 kfree(connkeys); 3718 rtnl_unlock(); 3719 return err; 3720 } 3721 3722 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info) 3723 { 3724 struct cfg80211_registered_device *rdev; 3725 struct net_device *dev; 3726 int err; 3727 3728 rtnl_lock(); 3729 3730 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3731 if (err) 3732 goto unlock_rtnl; 3733 3734 if (!rdev->ops->leave_ibss) { 3735 err = -EOPNOTSUPP; 3736 goto out; 3737 } 3738 3739 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) { 3740 err = -EOPNOTSUPP; 3741 goto out; 3742 } 3743 3744 if (!netif_running(dev)) { 3745 err = -ENETDOWN; 3746 goto out; 3747 } 3748 3749 err = cfg80211_leave_ibss(rdev, dev, false); 3750 3751 out: 3752 cfg80211_unlock_rdev(rdev); 3753 dev_put(dev); 3754 unlock_rtnl: 3755 rtnl_unlock(); 3756 return err; 3757 } 3758 3759 #ifdef CONFIG_NL80211_TESTMODE 3760 static struct genl_multicast_group nl80211_testmode_mcgrp = { 3761 .name = "testmode", 3762 }; 3763 3764 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info) 3765 { 3766 struct cfg80211_registered_device *rdev; 3767 int err; 3768 3769 if (!info->attrs[NL80211_ATTR_TESTDATA]) 3770 return -EINVAL; 3771 3772 rtnl_lock(); 3773 3774 rdev = cfg80211_get_dev_from_info(info); 3775 if (IS_ERR(rdev)) { 3776 err = PTR_ERR(rdev); 3777 goto unlock_rtnl; 3778 } 3779 3780 err = -EOPNOTSUPP; 3781 if (rdev->ops->testmode_cmd) { 3782 rdev->testmode_info = info; 3783 err = rdev->ops->testmode_cmd(&rdev->wiphy, 3784 nla_data(info->attrs[NL80211_ATTR_TESTDATA]), 3785 nla_len(info->attrs[NL80211_ATTR_TESTDATA])); 3786 rdev->testmode_info = NULL; 3787 } 3788 3789 cfg80211_unlock_rdev(rdev); 3790 3791 unlock_rtnl: 3792 rtnl_unlock(); 3793 return err; 3794 } 3795 3796 static struct sk_buff * 3797 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev, 3798 int approxlen, u32 pid, u32 seq, gfp_t gfp) 3799 { 3800 struct sk_buff *skb; 3801 void *hdr; 3802 struct nlattr *data; 3803 3804 skb = nlmsg_new(approxlen + 100, gfp); 3805 if (!skb) 3806 return NULL; 3807 3808 hdr = nl80211hdr_put(skb, pid, seq, 0, NL80211_CMD_TESTMODE); 3809 if (!hdr) { 3810 kfree_skb(skb); 3811 return NULL; 3812 } 3813 3814 NLA_PUT_U32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 3815 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA); 3816 3817 ((void **)skb->cb)[0] = rdev; 3818 ((void **)skb->cb)[1] = hdr; 3819 ((void **)skb->cb)[2] = data; 3820 3821 return skb; 3822 3823 nla_put_failure: 3824 kfree_skb(skb); 3825 return NULL; 3826 } 3827 3828 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy, 3829 int approxlen) 3830 { 3831 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 3832 3833 if (WARN_ON(!rdev->testmode_info)) 3834 return NULL; 3835 3836 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 3837 rdev->testmode_info->snd_pid, 3838 rdev->testmode_info->snd_seq, 3839 GFP_KERNEL); 3840 } 3841 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb); 3842 3843 int cfg80211_testmode_reply(struct sk_buff *skb) 3844 { 3845 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0]; 3846 void *hdr = ((void **)skb->cb)[1]; 3847 struct nlattr *data = ((void **)skb->cb)[2]; 3848 3849 if (WARN_ON(!rdev->testmode_info)) { 3850 kfree_skb(skb); 3851 return -EINVAL; 3852 } 3853 3854 nla_nest_end(skb, data); 3855 genlmsg_end(skb, hdr); 3856 return genlmsg_reply(skb, rdev->testmode_info); 3857 } 3858 EXPORT_SYMBOL(cfg80211_testmode_reply); 3859 3860 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy, 3861 int approxlen, gfp_t gfp) 3862 { 3863 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 3864 3865 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp); 3866 } 3867 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb); 3868 3869 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp) 3870 { 3871 void *hdr = ((void **)skb->cb)[1]; 3872 struct nlattr *data = ((void **)skb->cb)[2]; 3873 3874 nla_nest_end(skb, data); 3875 genlmsg_end(skb, hdr); 3876 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp); 3877 } 3878 EXPORT_SYMBOL(cfg80211_testmode_event); 3879 #endif 3880 3881 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info) 3882 { 3883 struct cfg80211_registered_device *rdev; 3884 struct net_device *dev; 3885 struct cfg80211_connect_params connect; 3886 struct wiphy *wiphy; 3887 struct cfg80211_cached_keys *connkeys = NULL; 3888 int err; 3889 3890 memset(&connect, 0, sizeof(connect)); 3891 3892 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) 3893 return -EINVAL; 3894 3895 if (!info->attrs[NL80211_ATTR_SSID] || 3896 !nla_len(info->attrs[NL80211_ATTR_SSID])) 3897 return -EINVAL; 3898 3899 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) { 3900 connect.auth_type = 3901 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]); 3902 if (!nl80211_valid_auth_type(connect.auth_type)) 3903 return -EINVAL; 3904 } else 3905 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC; 3906 3907 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY]; 3908 3909 err = nl80211_crypto_settings(info, &connect.crypto, 3910 NL80211_MAX_NR_CIPHER_SUITES); 3911 if (err) 3912 return err; 3913 rtnl_lock(); 3914 3915 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3916 if (err) 3917 goto unlock_rtnl; 3918 3919 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) { 3920 err = -EOPNOTSUPP; 3921 goto out; 3922 } 3923 3924 if (!netif_running(dev)) { 3925 err = -ENETDOWN; 3926 goto out; 3927 } 3928 3929 wiphy = &rdev->wiphy; 3930 3931 if (info->attrs[NL80211_ATTR_MAC]) 3932 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 3933 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 3934 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 3935 3936 if (info->attrs[NL80211_ATTR_IE]) { 3937 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 3938 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 3939 } 3940 3941 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) { 3942 connect.channel = 3943 ieee80211_get_channel(wiphy, 3944 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ])); 3945 if (!connect.channel || 3946 connect.channel->flags & IEEE80211_CHAN_DISABLED) { 3947 err = -EINVAL; 3948 goto out; 3949 } 3950 } 3951 3952 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) { 3953 connkeys = nl80211_parse_connkeys(rdev, 3954 info->attrs[NL80211_ATTR_KEYS]); 3955 if (IS_ERR(connkeys)) { 3956 err = PTR_ERR(connkeys); 3957 connkeys = NULL; 3958 goto out; 3959 } 3960 } 3961 3962 err = cfg80211_connect(rdev, dev, &connect, connkeys); 3963 3964 out: 3965 cfg80211_unlock_rdev(rdev); 3966 dev_put(dev); 3967 unlock_rtnl: 3968 if (err) 3969 kfree(connkeys); 3970 rtnl_unlock(); 3971 return err; 3972 } 3973 3974 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info) 3975 { 3976 struct cfg80211_registered_device *rdev; 3977 struct net_device *dev; 3978 int err; 3979 u16 reason; 3980 3981 if (!info->attrs[NL80211_ATTR_REASON_CODE]) 3982 reason = WLAN_REASON_DEAUTH_LEAVING; 3983 else 3984 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]); 3985 3986 if (reason == 0) 3987 return -EINVAL; 3988 3989 rtnl_lock(); 3990 3991 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev); 3992 if (err) 3993 goto unlock_rtnl; 3994 3995 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) { 3996 err = -EOPNOTSUPP; 3997 goto out; 3998 } 3999 4000 if (!netif_running(dev)) { 4001 err = -ENETDOWN; 4002 goto out; 4003 } 4004 4005 err = cfg80211_disconnect(rdev, dev, reason, true); 4006 4007 out: 4008 cfg80211_unlock_rdev(rdev); 4009 dev_put(dev); 4010 unlock_rtnl: 4011 rtnl_unlock(); 4012 return err; 4013 } 4014 4015 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info) 4016 { 4017 struct cfg80211_registered_device *rdev; 4018 struct net *net; 4019 int err; 4020 u32 pid; 4021 4022 if (!info->attrs[NL80211_ATTR_PID]) 4023 return -EINVAL; 4024 4025 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]); 4026 4027 rtnl_lock(); 4028 4029 rdev = cfg80211_get_dev_from_info(info); 4030 if (IS_ERR(rdev)) { 4031 err = PTR_ERR(rdev); 4032 goto out; 4033 } 4034 4035 net = get_net_ns_by_pid(pid); 4036 if (IS_ERR(net)) { 4037 err = PTR_ERR(net); 4038 goto out; 4039 } 4040 4041 err = 0; 4042 4043 /* check if anything to do */ 4044 if (net_eq(wiphy_net(&rdev->wiphy), net)) 4045 goto out_put_net; 4046 4047 err = cfg80211_switch_netns(rdev, net); 4048 out_put_net: 4049 put_net(net); 4050 out: 4051 cfg80211_unlock_rdev(rdev); 4052 rtnl_unlock(); 4053 return err; 4054 } 4055 4056 static struct genl_ops nl80211_ops[] = { 4057 { 4058 .cmd = NL80211_CMD_GET_WIPHY, 4059 .doit = nl80211_get_wiphy, 4060 .dumpit = nl80211_dump_wiphy, 4061 .policy = nl80211_policy, 4062 /* can be retrieved by unprivileged users */ 4063 }, 4064 { 4065 .cmd = NL80211_CMD_SET_WIPHY, 4066 .doit = nl80211_set_wiphy, 4067 .policy = nl80211_policy, 4068 .flags = GENL_ADMIN_PERM, 4069 }, 4070 { 4071 .cmd = NL80211_CMD_GET_INTERFACE, 4072 .doit = nl80211_get_interface, 4073 .dumpit = nl80211_dump_interface, 4074 .policy = nl80211_policy, 4075 /* can be retrieved by unprivileged users */ 4076 }, 4077 { 4078 .cmd = NL80211_CMD_SET_INTERFACE, 4079 .doit = nl80211_set_interface, 4080 .policy = nl80211_policy, 4081 .flags = GENL_ADMIN_PERM, 4082 }, 4083 { 4084 .cmd = NL80211_CMD_NEW_INTERFACE, 4085 .doit = nl80211_new_interface, 4086 .policy = nl80211_policy, 4087 .flags = GENL_ADMIN_PERM, 4088 }, 4089 { 4090 .cmd = NL80211_CMD_DEL_INTERFACE, 4091 .doit = nl80211_del_interface, 4092 .policy = nl80211_policy, 4093 .flags = GENL_ADMIN_PERM, 4094 }, 4095 { 4096 .cmd = NL80211_CMD_GET_KEY, 4097 .doit = nl80211_get_key, 4098 .policy = nl80211_policy, 4099 .flags = GENL_ADMIN_PERM, 4100 }, 4101 { 4102 .cmd = NL80211_CMD_SET_KEY, 4103 .doit = nl80211_set_key, 4104 .policy = nl80211_policy, 4105 .flags = GENL_ADMIN_PERM, 4106 }, 4107 { 4108 .cmd = NL80211_CMD_NEW_KEY, 4109 .doit = nl80211_new_key, 4110 .policy = nl80211_policy, 4111 .flags = GENL_ADMIN_PERM, 4112 }, 4113 { 4114 .cmd = NL80211_CMD_DEL_KEY, 4115 .doit = nl80211_del_key, 4116 .policy = nl80211_policy, 4117 .flags = GENL_ADMIN_PERM, 4118 }, 4119 { 4120 .cmd = NL80211_CMD_SET_BEACON, 4121 .policy = nl80211_policy, 4122 .flags = GENL_ADMIN_PERM, 4123 .doit = nl80211_addset_beacon, 4124 }, 4125 { 4126 .cmd = NL80211_CMD_NEW_BEACON, 4127 .policy = nl80211_policy, 4128 .flags = GENL_ADMIN_PERM, 4129 .doit = nl80211_addset_beacon, 4130 }, 4131 { 4132 .cmd = NL80211_CMD_DEL_BEACON, 4133 .policy = nl80211_policy, 4134 .flags = GENL_ADMIN_PERM, 4135 .doit = nl80211_del_beacon, 4136 }, 4137 { 4138 .cmd = NL80211_CMD_GET_STATION, 4139 .doit = nl80211_get_station, 4140 .dumpit = nl80211_dump_station, 4141 .policy = nl80211_policy, 4142 }, 4143 { 4144 .cmd = NL80211_CMD_SET_STATION, 4145 .doit = nl80211_set_station, 4146 .policy = nl80211_policy, 4147 .flags = GENL_ADMIN_PERM, 4148 }, 4149 { 4150 .cmd = NL80211_CMD_NEW_STATION, 4151 .doit = nl80211_new_station, 4152 .policy = nl80211_policy, 4153 .flags = GENL_ADMIN_PERM, 4154 }, 4155 { 4156 .cmd = NL80211_CMD_DEL_STATION, 4157 .doit = nl80211_del_station, 4158 .policy = nl80211_policy, 4159 .flags = GENL_ADMIN_PERM, 4160 }, 4161 { 4162 .cmd = NL80211_CMD_GET_MPATH, 4163 .doit = nl80211_get_mpath, 4164 .dumpit = nl80211_dump_mpath, 4165 .policy = nl80211_policy, 4166 .flags = GENL_ADMIN_PERM, 4167 }, 4168 { 4169 .cmd = NL80211_CMD_SET_MPATH, 4170 .doit = nl80211_set_mpath, 4171 .policy = nl80211_policy, 4172 .flags = GENL_ADMIN_PERM, 4173 }, 4174 { 4175 .cmd = NL80211_CMD_NEW_MPATH, 4176 .doit = nl80211_new_mpath, 4177 .policy = nl80211_policy, 4178 .flags = GENL_ADMIN_PERM, 4179 }, 4180 { 4181 .cmd = NL80211_CMD_DEL_MPATH, 4182 .doit = nl80211_del_mpath, 4183 .policy = nl80211_policy, 4184 .flags = GENL_ADMIN_PERM, 4185 }, 4186 { 4187 .cmd = NL80211_CMD_SET_BSS, 4188 .doit = nl80211_set_bss, 4189 .policy = nl80211_policy, 4190 .flags = GENL_ADMIN_PERM, 4191 }, 4192 { 4193 .cmd = NL80211_CMD_GET_REG, 4194 .doit = nl80211_get_reg, 4195 .policy = nl80211_policy, 4196 /* can be retrieved by unprivileged users */ 4197 }, 4198 { 4199 .cmd = NL80211_CMD_SET_REG, 4200 .doit = nl80211_set_reg, 4201 .policy = nl80211_policy, 4202 .flags = GENL_ADMIN_PERM, 4203 }, 4204 { 4205 .cmd = NL80211_CMD_REQ_SET_REG, 4206 .doit = nl80211_req_set_reg, 4207 .policy = nl80211_policy, 4208 .flags = GENL_ADMIN_PERM, 4209 }, 4210 { 4211 .cmd = NL80211_CMD_GET_MESH_PARAMS, 4212 .doit = nl80211_get_mesh_params, 4213 .policy = nl80211_policy, 4214 /* can be retrieved by unprivileged users */ 4215 }, 4216 { 4217 .cmd = NL80211_CMD_SET_MESH_PARAMS, 4218 .doit = nl80211_set_mesh_params, 4219 .policy = nl80211_policy, 4220 .flags = GENL_ADMIN_PERM, 4221 }, 4222 { 4223 .cmd = NL80211_CMD_TRIGGER_SCAN, 4224 .doit = nl80211_trigger_scan, 4225 .policy = nl80211_policy, 4226 .flags = GENL_ADMIN_PERM, 4227 }, 4228 { 4229 .cmd = NL80211_CMD_GET_SCAN, 4230 .policy = nl80211_policy, 4231 .dumpit = nl80211_dump_scan, 4232 }, 4233 { 4234 .cmd = NL80211_CMD_AUTHENTICATE, 4235 .doit = nl80211_authenticate, 4236 .policy = nl80211_policy, 4237 .flags = GENL_ADMIN_PERM, 4238 }, 4239 { 4240 .cmd = NL80211_CMD_ASSOCIATE, 4241 .doit = nl80211_associate, 4242 .policy = nl80211_policy, 4243 .flags = GENL_ADMIN_PERM, 4244 }, 4245 { 4246 .cmd = NL80211_CMD_DEAUTHENTICATE, 4247 .doit = nl80211_deauthenticate, 4248 .policy = nl80211_policy, 4249 .flags = GENL_ADMIN_PERM, 4250 }, 4251 { 4252 .cmd = NL80211_CMD_DISASSOCIATE, 4253 .doit = nl80211_disassociate, 4254 .policy = nl80211_policy, 4255 .flags = GENL_ADMIN_PERM, 4256 }, 4257 { 4258 .cmd = NL80211_CMD_JOIN_IBSS, 4259 .doit = nl80211_join_ibss, 4260 .policy = nl80211_policy, 4261 .flags = GENL_ADMIN_PERM, 4262 }, 4263 { 4264 .cmd = NL80211_CMD_LEAVE_IBSS, 4265 .doit = nl80211_leave_ibss, 4266 .policy = nl80211_policy, 4267 .flags = GENL_ADMIN_PERM, 4268 }, 4269 #ifdef CONFIG_NL80211_TESTMODE 4270 { 4271 .cmd = NL80211_CMD_TESTMODE, 4272 .doit = nl80211_testmode_do, 4273 .policy = nl80211_policy, 4274 .flags = GENL_ADMIN_PERM, 4275 }, 4276 #endif 4277 { 4278 .cmd = NL80211_CMD_CONNECT, 4279 .doit = nl80211_connect, 4280 .policy = nl80211_policy, 4281 .flags = GENL_ADMIN_PERM, 4282 }, 4283 { 4284 .cmd = NL80211_CMD_DISCONNECT, 4285 .doit = nl80211_disconnect, 4286 .policy = nl80211_policy, 4287 .flags = GENL_ADMIN_PERM, 4288 }, 4289 { 4290 .cmd = NL80211_CMD_SET_WIPHY_NETNS, 4291 .doit = nl80211_wiphy_netns, 4292 .policy = nl80211_policy, 4293 .flags = GENL_ADMIN_PERM, 4294 }, 4295 }; 4296 static struct genl_multicast_group nl80211_mlme_mcgrp = { 4297 .name = "mlme", 4298 }; 4299 4300 /* multicast groups */ 4301 static struct genl_multicast_group nl80211_config_mcgrp = { 4302 .name = "config", 4303 }; 4304 static struct genl_multicast_group nl80211_scan_mcgrp = { 4305 .name = "scan", 4306 }; 4307 static struct genl_multicast_group nl80211_regulatory_mcgrp = { 4308 .name = "regulatory", 4309 }; 4310 4311 /* notification functions */ 4312 4313 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev) 4314 { 4315 struct sk_buff *msg; 4316 4317 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 4318 if (!msg) 4319 return; 4320 4321 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) { 4322 nlmsg_free(msg); 4323 return; 4324 } 4325 4326 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4327 nl80211_config_mcgrp.id, GFP_KERNEL); 4328 } 4329 4330 static int nl80211_add_scan_req(struct sk_buff *msg, 4331 struct cfg80211_registered_device *rdev) 4332 { 4333 struct cfg80211_scan_request *req = rdev->scan_req; 4334 struct nlattr *nest; 4335 int i; 4336 4337 ASSERT_RDEV_LOCK(rdev); 4338 4339 if (WARN_ON(!req)) 4340 return 0; 4341 4342 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS); 4343 if (!nest) 4344 goto nla_put_failure; 4345 for (i = 0; i < req->n_ssids; i++) 4346 NLA_PUT(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid); 4347 nla_nest_end(msg, nest); 4348 4349 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES); 4350 if (!nest) 4351 goto nla_put_failure; 4352 for (i = 0; i < req->n_channels; i++) 4353 NLA_PUT_U32(msg, i, req->channels[i]->center_freq); 4354 nla_nest_end(msg, nest); 4355 4356 if (req->ie) 4357 NLA_PUT(msg, NL80211_ATTR_IE, req->ie_len, req->ie); 4358 4359 return 0; 4360 nla_put_failure: 4361 return -ENOBUFS; 4362 } 4363 4364 static int nl80211_send_scan_msg(struct sk_buff *msg, 4365 struct cfg80211_registered_device *rdev, 4366 struct net_device *netdev, 4367 u32 pid, u32 seq, int flags, 4368 u32 cmd) 4369 { 4370 void *hdr; 4371 4372 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd); 4373 if (!hdr) 4374 return -1; 4375 4376 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4377 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4378 4379 /* ignore errors and send incomplete event anyway */ 4380 nl80211_add_scan_req(msg, rdev); 4381 4382 return genlmsg_end(msg, hdr); 4383 4384 nla_put_failure: 4385 genlmsg_cancel(msg, hdr); 4386 return -EMSGSIZE; 4387 } 4388 4389 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev, 4390 struct net_device *netdev) 4391 { 4392 struct sk_buff *msg; 4393 4394 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 4395 if (!msg) 4396 return; 4397 4398 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0, 4399 NL80211_CMD_TRIGGER_SCAN) < 0) { 4400 nlmsg_free(msg); 4401 return; 4402 } 4403 4404 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4405 nl80211_scan_mcgrp.id, GFP_KERNEL); 4406 } 4407 4408 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev, 4409 struct net_device *netdev) 4410 { 4411 struct sk_buff *msg; 4412 4413 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 4414 if (!msg) 4415 return; 4416 4417 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0, 4418 NL80211_CMD_NEW_SCAN_RESULTS) < 0) { 4419 nlmsg_free(msg); 4420 return; 4421 } 4422 4423 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4424 nl80211_scan_mcgrp.id, GFP_KERNEL); 4425 } 4426 4427 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev, 4428 struct net_device *netdev) 4429 { 4430 struct sk_buff *msg; 4431 4432 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 4433 if (!msg) 4434 return; 4435 4436 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0, 4437 NL80211_CMD_SCAN_ABORTED) < 0) { 4438 nlmsg_free(msg); 4439 return; 4440 } 4441 4442 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4443 nl80211_scan_mcgrp.id, GFP_KERNEL); 4444 } 4445 4446 /* 4447 * This can happen on global regulatory changes or device specific settings 4448 * based on custom world regulatory domains. 4449 */ 4450 void nl80211_send_reg_change_event(struct regulatory_request *request) 4451 { 4452 struct sk_buff *msg; 4453 void *hdr; 4454 4455 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 4456 if (!msg) 4457 return; 4458 4459 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE); 4460 if (!hdr) { 4461 nlmsg_free(msg); 4462 return; 4463 } 4464 4465 /* Userspace can always count this one always being set */ 4466 NLA_PUT_U8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator); 4467 4468 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') 4469 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE, 4470 NL80211_REGDOM_TYPE_WORLD); 4471 else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') 4472 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE, 4473 NL80211_REGDOM_TYPE_CUSTOM_WORLD); 4474 else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') || 4475 request->intersect) 4476 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE, 4477 NL80211_REGDOM_TYPE_INTERSECTION); 4478 else { 4479 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE, 4480 NL80211_REGDOM_TYPE_COUNTRY); 4481 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, request->alpha2); 4482 } 4483 4484 if (wiphy_idx_valid(request->wiphy_idx)) 4485 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx); 4486 4487 if (genlmsg_end(msg, hdr) < 0) { 4488 nlmsg_free(msg); 4489 return; 4490 } 4491 4492 rcu_read_lock(); 4493 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id, 4494 GFP_ATOMIC); 4495 rcu_read_unlock(); 4496 4497 return; 4498 4499 nla_put_failure: 4500 genlmsg_cancel(msg, hdr); 4501 nlmsg_free(msg); 4502 } 4503 4504 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev, 4505 struct net_device *netdev, 4506 const u8 *buf, size_t len, 4507 enum nl80211_commands cmd, gfp_t gfp) 4508 { 4509 struct sk_buff *msg; 4510 void *hdr; 4511 4512 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 4513 if (!msg) 4514 return; 4515 4516 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 4517 if (!hdr) { 4518 nlmsg_free(msg); 4519 return; 4520 } 4521 4522 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4523 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4524 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf); 4525 4526 if (genlmsg_end(msg, hdr) < 0) { 4527 nlmsg_free(msg); 4528 return; 4529 } 4530 4531 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4532 nl80211_mlme_mcgrp.id, gfp); 4533 return; 4534 4535 nla_put_failure: 4536 genlmsg_cancel(msg, hdr); 4537 nlmsg_free(msg); 4538 } 4539 4540 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev, 4541 struct net_device *netdev, const u8 *buf, 4542 size_t len, gfp_t gfp) 4543 { 4544 nl80211_send_mlme_event(rdev, netdev, buf, len, 4545 NL80211_CMD_AUTHENTICATE, gfp); 4546 } 4547 4548 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev, 4549 struct net_device *netdev, const u8 *buf, 4550 size_t len, gfp_t gfp) 4551 { 4552 nl80211_send_mlme_event(rdev, netdev, buf, len, 4553 NL80211_CMD_ASSOCIATE, gfp); 4554 } 4555 4556 void nl80211_send_deauth(struct cfg80211_registered_device *rdev, 4557 struct net_device *netdev, const u8 *buf, 4558 size_t len, gfp_t gfp) 4559 { 4560 nl80211_send_mlme_event(rdev, netdev, buf, len, 4561 NL80211_CMD_DEAUTHENTICATE, gfp); 4562 } 4563 4564 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev, 4565 struct net_device *netdev, const u8 *buf, 4566 size_t len, gfp_t gfp) 4567 { 4568 nl80211_send_mlme_event(rdev, netdev, buf, len, 4569 NL80211_CMD_DISASSOCIATE, gfp); 4570 } 4571 4572 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev, 4573 struct net_device *netdev, int cmd, 4574 const u8 *addr, gfp_t gfp) 4575 { 4576 struct sk_buff *msg; 4577 void *hdr; 4578 4579 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 4580 if (!msg) 4581 return; 4582 4583 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 4584 if (!hdr) { 4585 nlmsg_free(msg); 4586 return; 4587 } 4588 4589 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4590 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4591 NLA_PUT_FLAG(msg, NL80211_ATTR_TIMED_OUT); 4592 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr); 4593 4594 if (genlmsg_end(msg, hdr) < 0) { 4595 nlmsg_free(msg); 4596 return; 4597 } 4598 4599 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4600 nl80211_mlme_mcgrp.id, gfp); 4601 return; 4602 4603 nla_put_failure: 4604 genlmsg_cancel(msg, hdr); 4605 nlmsg_free(msg); 4606 } 4607 4608 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev, 4609 struct net_device *netdev, const u8 *addr, 4610 gfp_t gfp) 4611 { 4612 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE, 4613 addr, gfp); 4614 } 4615 4616 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev, 4617 struct net_device *netdev, const u8 *addr, 4618 gfp_t gfp) 4619 { 4620 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE, 4621 addr, gfp); 4622 } 4623 4624 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev, 4625 struct net_device *netdev, const u8 *bssid, 4626 const u8 *req_ie, size_t req_ie_len, 4627 const u8 *resp_ie, size_t resp_ie_len, 4628 u16 status, gfp_t gfp) 4629 { 4630 struct sk_buff *msg; 4631 void *hdr; 4632 4633 msg = nlmsg_new(NLMSG_GOODSIZE, gfp); 4634 if (!msg) 4635 return; 4636 4637 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT); 4638 if (!hdr) { 4639 nlmsg_free(msg); 4640 return; 4641 } 4642 4643 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4644 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4645 if (bssid) 4646 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid); 4647 NLA_PUT_U16(msg, NL80211_ATTR_STATUS_CODE, status); 4648 if (req_ie) 4649 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie); 4650 if (resp_ie) 4651 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie); 4652 4653 if (genlmsg_end(msg, hdr) < 0) { 4654 nlmsg_free(msg); 4655 return; 4656 } 4657 4658 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4659 nl80211_mlme_mcgrp.id, gfp); 4660 return; 4661 4662 nla_put_failure: 4663 genlmsg_cancel(msg, hdr); 4664 nlmsg_free(msg); 4665 4666 } 4667 4668 void nl80211_send_roamed(struct cfg80211_registered_device *rdev, 4669 struct net_device *netdev, const u8 *bssid, 4670 const u8 *req_ie, size_t req_ie_len, 4671 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp) 4672 { 4673 struct sk_buff *msg; 4674 void *hdr; 4675 4676 msg = nlmsg_new(NLMSG_GOODSIZE, gfp); 4677 if (!msg) 4678 return; 4679 4680 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM); 4681 if (!hdr) { 4682 nlmsg_free(msg); 4683 return; 4684 } 4685 4686 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4687 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4688 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid); 4689 if (req_ie) 4690 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie); 4691 if (resp_ie) 4692 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie); 4693 4694 if (genlmsg_end(msg, hdr) < 0) { 4695 nlmsg_free(msg); 4696 return; 4697 } 4698 4699 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4700 nl80211_mlme_mcgrp.id, gfp); 4701 return; 4702 4703 nla_put_failure: 4704 genlmsg_cancel(msg, hdr); 4705 nlmsg_free(msg); 4706 4707 } 4708 4709 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev, 4710 struct net_device *netdev, u16 reason, 4711 const u8 *ie, size_t ie_len, bool from_ap) 4712 { 4713 struct sk_buff *msg; 4714 void *hdr; 4715 4716 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 4717 if (!msg) 4718 return; 4719 4720 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT); 4721 if (!hdr) { 4722 nlmsg_free(msg); 4723 return; 4724 } 4725 4726 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4727 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4728 if (from_ap && reason) 4729 NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason); 4730 if (from_ap) 4731 NLA_PUT_FLAG(msg, NL80211_ATTR_DISCONNECTED_BY_AP); 4732 if (ie) 4733 NLA_PUT(msg, NL80211_ATTR_IE, ie_len, ie); 4734 4735 if (genlmsg_end(msg, hdr) < 0) { 4736 nlmsg_free(msg); 4737 return; 4738 } 4739 4740 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4741 nl80211_mlme_mcgrp.id, GFP_KERNEL); 4742 return; 4743 4744 nla_put_failure: 4745 genlmsg_cancel(msg, hdr); 4746 nlmsg_free(msg); 4747 4748 } 4749 4750 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev, 4751 struct net_device *netdev, const u8 *bssid, 4752 gfp_t gfp) 4753 { 4754 struct sk_buff *msg; 4755 void *hdr; 4756 4757 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 4758 if (!msg) 4759 return; 4760 4761 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS); 4762 if (!hdr) { 4763 nlmsg_free(msg); 4764 return; 4765 } 4766 4767 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4768 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4769 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid); 4770 4771 if (genlmsg_end(msg, hdr) < 0) { 4772 nlmsg_free(msg); 4773 return; 4774 } 4775 4776 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4777 nl80211_mlme_mcgrp.id, gfp); 4778 return; 4779 4780 nla_put_failure: 4781 genlmsg_cancel(msg, hdr); 4782 nlmsg_free(msg); 4783 } 4784 4785 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev, 4786 struct net_device *netdev, const u8 *addr, 4787 enum nl80211_key_type key_type, int key_id, 4788 const u8 *tsc, gfp_t gfp) 4789 { 4790 struct sk_buff *msg; 4791 void *hdr; 4792 4793 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 4794 if (!msg) 4795 return; 4796 4797 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE); 4798 if (!hdr) { 4799 nlmsg_free(msg); 4800 return; 4801 } 4802 4803 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx); 4804 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex); 4805 if (addr) 4806 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr); 4807 NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type); 4808 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id); 4809 if (tsc) 4810 NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc); 4811 4812 if (genlmsg_end(msg, hdr) < 0) { 4813 nlmsg_free(msg); 4814 return; 4815 } 4816 4817 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0, 4818 nl80211_mlme_mcgrp.id, gfp); 4819 return; 4820 4821 nla_put_failure: 4822 genlmsg_cancel(msg, hdr); 4823 nlmsg_free(msg); 4824 } 4825 4826 void nl80211_send_beacon_hint_event(struct wiphy *wiphy, 4827 struct ieee80211_channel *channel_before, 4828 struct ieee80211_channel *channel_after) 4829 { 4830 struct sk_buff *msg; 4831 void *hdr; 4832 struct nlattr *nl_freq; 4833 4834 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 4835 if (!msg) 4836 return; 4837 4838 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT); 4839 if (!hdr) { 4840 nlmsg_free(msg); 4841 return; 4842 } 4843 4844 /* 4845 * Since we are applying the beacon hint to a wiphy we know its 4846 * wiphy_idx is valid 4847 */ 4848 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)); 4849 4850 /* Before */ 4851 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE); 4852 if (!nl_freq) 4853 goto nla_put_failure; 4854 if (nl80211_msg_put_channel(msg, channel_before)) 4855 goto nla_put_failure; 4856 nla_nest_end(msg, nl_freq); 4857 4858 /* After */ 4859 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER); 4860 if (!nl_freq) 4861 goto nla_put_failure; 4862 if (nl80211_msg_put_channel(msg, channel_after)) 4863 goto nla_put_failure; 4864 nla_nest_end(msg, nl_freq); 4865 4866 if (genlmsg_end(msg, hdr) < 0) { 4867 nlmsg_free(msg); 4868 return; 4869 } 4870 4871 rcu_read_lock(); 4872 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id, 4873 GFP_ATOMIC); 4874 rcu_read_unlock(); 4875 4876 return; 4877 4878 nla_put_failure: 4879 genlmsg_cancel(msg, hdr); 4880 nlmsg_free(msg); 4881 } 4882 4883 /* initialisation/exit functions */ 4884 4885 int nl80211_init(void) 4886 { 4887 int err; 4888 4889 err = genl_register_family_with_ops(&nl80211_fam, 4890 nl80211_ops, ARRAY_SIZE(nl80211_ops)); 4891 if (err) 4892 return err; 4893 4894 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp); 4895 if (err) 4896 goto err_out; 4897 4898 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp); 4899 if (err) 4900 goto err_out; 4901 4902 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp); 4903 if (err) 4904 goto err_out; 4905 4906 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp); 4907 if (err) 4908 goto err_out; 4909 4910 #ifdef CONFIG_NL80211_TESTMODE 4911 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp); 4912 if (err) 4913 goto err_out; 4914 #endif 4915 4916 return 0; 4917 err_out: 4918 genl_unregister_family(&nl80211_fam); 4919 return err; 4920 } 4921 4922 void nl80211_exit(void) 4923 { 4924 genl_unregister_family(&nl80211_fam); 4925 } 4926