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