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