1 /* 2 * mac80211 configuration hooks for cfg80211 3 * 4 * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net> 5 * 6 * This file is GPLv2 as found in COPYING. 7 */ 8 9 #include <linux/ieee80211.h> 10 #include <linux/nl80211.h> 11 #include <linux/rtnetlink.h> 12 #include <net/net_namespace.h> 13 #include <linux/rcupdate.h> 14 #include <net/cfg80211.h> 15 #include "ieee80211_i.h" 16 #include "cfg.h" 17 #include "rate.h" 18 #include "mesh.h" 19 20 struct ieee80211_hw *wiphy_to_hw(struct wiphy *wiphy) 21 { 22 struct ieee80211_local *local = wiphy_priv(wiphy); 23 return &local->hw; 24 } 25 EXPORT_SYMBOL(wiphy_to_hw); 26 27 static bool nl80211_type_check(enum nl80211_iftype type) 28 { 29 switch (type) { 30 case NL80211_IFTYPE_ADHOC: 31 case NL80211_IFTYPE_STATION: 32 case NL80211_IFTYPE_MONITOR: 33 #ifdef CONFIG_MAC80211_MESH 34 case NL80211_IFTYPE_MESH_POINT: 35 #endif 36 case NL80211_IFTYPE_WDS: 37 return true; 38 default: 39 return false; 40 } 41 } 42 43 static int ieee80211_add_iface(struct wiphy *wiphy, char *name, 44 enum nl80211_iftype type, u32 *flags, 45 struct vif_params *params) 46 { 47 struct ieee80211_local *local = wiphy_priv(wiphy); 48 struct net_device *dev; 49 struct ieee80211_sub_if_data *sdata; 50 int err; 51 52 if (!nl80211_type_check(type)) 53 return -EINVAL; 54 55 err = ieee80211_if_add(local, name, &dev, type, params); 56 if (err || type != NL80211_IFTYPE_MONITOR || !flags) 57 return err; 58 59 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 60 sdata->u.mntr_flags = *flags; 61 return 0; 62 } 63 64 static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex) 65 { 66 struct net_device *dev; 67 struct ieee80211_sub_if_data *sdata; 68 69 /* we're under RTNL */ 70 dev = __dev_get_by_index(&init_net, ifindex); 71 if (!dev) 72 return -ENODEV; 73 74 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 75 76 ieee80211_if_remove(sdata); 77 78 return 0; 79 } 80 81 static int ieee80211_change_iface(struct wiphy *wiphy, int ifindex, 82 enum nl80211_iftype type, u32 *flags, 83 struct vif_params *params) 84 { 85 struct net_device *dev; 86 struct ieee80211_sub_if_data *sdata; 87 int ret; 88 89 /* we're under RTNL */ 90 dev = __dev_get_by_index(&init_net, ifindex); 91 if (!dev) 92 return -ENODEV; 93 94 if (!nl80211_type_check(type)) 95 return -EINVAL; 96 97 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 98 99 ret = ieee80211_if_change_type(sdata, type); 100 if (ret) 101 return ret; 102 103 if (netif_running(sdata->dev)) 104 return -EBUSY; 105 106 if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len) 107 ieee80211_sdata_set_mesh_id(sdata, 108 params->mesh_id_len, 109 params->mesh_id); 110 111 if (sdata->vif.type != NL80211_IFTYPE_MONITOR || !flags) 112 return 0; 113 114 sdata->u.mntr_flags = *flags; 115 return 0; 116 } 117 118 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev, 119 u8 key_idx, u8 *mac_addr, 120 struct key_params *params) 121 { 122 struct ieee80211_sub_if_data *sdata; 123 struct sta_info *sta = NULL; 124 enum ieee80211_key_alg alg; 125 struct ieee80211_key *key; 126 int err; 127 128 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 129 130 switch (params->cipher) { 131 case WLAN_CIPHER_SUITE_WEP40: 132 case WLAN_CIPHER_SUITE_WEP104: 133 alg = ALG_WEP; 134 break; 135 case WLAN_CIPHER_SUITE_TKIP: 136 alg = ALG_TKIP; 137 break; 138 case WLAN_CIPHER_SUITE_CCMP: 139 alg = ALG_CCMP; 140 break; 141 default: 142 return -EINVAL; 143 } 144 145 key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key); 146 if (!key) 147 return -ENOMEM; 148 149 rcu_read_lock(); 150 151 if (mac_addr) { 152 sta = sta_info_get(sdata->local, mac_addr); 153 if (!sta) { 154 ieee80211_key_free(key); 155 err = -ENOENT; 156 goto out_unlock; 157 } 158 } 159 160 ieee80211_key_link(key, sdata, sta); 161 162 err = 0; 163 out_unlock: 164 rcu_read_unlock(); 165 166 return err; 167 } 168 169 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev, 170 u8 key_idx, u8 *mac_addr) 171 { 172 struct ieee80211_sub_if_data *sdata; 173 struct sta_info *sta; 174 int ret; 175 176 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 177 178 rcu_read_lock(); 179 180 if (mac_addr) { 181 ret = -ENOENT; 182 183 sta = sta_info_get(sdata->local, mac_addr); 184 if (!sta) 185 goto out_unlock; 186 187 if (sta->key) { 188 ieee80211_key_free(sta->key); 189 WARN_ON(sta->key); 190 ret = 0; 191 } 192 193 goto out_unlock; 194 } 195 196 if (!sdata->keys[key_idx]) { 197 ret = -ENOENT; 198 goto out_unlock; 199 } 200 201 ieee80211_key_free(sdata->keys[key_idx]); 202 WARN_ON(sdata->keys[key_idx]); 203 204 ret = 0; 205 out_unlock: 206 rcu_read_unlock(); 207 208 return ret; 209 } 210 211 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev, 212 u8 key_idx, u8 *mac_addr, void *cookie, 213 void (*callback)(void *cookie, 214 struct key_params *params)) 215 { 216 struct ieee80211_sub_if_data *sdata; 217 struct sta_info *sta = NULL; 218 u8 seq[6] = {0}; 219 struct key_params params; 220 struct ieee80211_key *key; 221 u32 iv32; 222 u16 iv16; 223 int err = -ENOENT; 224 225 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 226 227 rcu_read_lock(); 228 229 if (mac_addr) { 230 sta = sta_info_get(sdata->local, mac_addr); 231 if (!sta) 232 goto out; 233 234 key = sta->key; 235 } else 236 key = sdata->keys[key_idx]; 237 238 if (!key) 239 goto out; 240 241 memset(¶ms, 0, sizeof(params)); 242 243 switch (key->conf.alg) { 244 case ALG_TKIP: 245 params.cipher = WLAN_CIPHER_SUITE_TKIP; 246 247 iv32 = key->u.tkip.tx.iv32; 248 iv16 = key->u.tkip.tx.iv16; 249 250 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE && 251 sdata->local->ops->get_tkip_seq) 252 sdata->local->ops->get_tkip_seq( 253 local_to_hw(sdata->local), 254 key->conf.hw_key_idx, 255 &iv32, &iv16); 256 257 seq[0] = iv16 & 0xff; 258 seq[1] = (iv16 >> 8) & 0xff; 259 seq[2] = iv32 & 0xff; 260 seq[3] = (iv32 >> 8) & 0xff; 261 seq[4] = (iv32 >> 16) & 0xff; 262 seq[5] = (iv32 >> 24) & 0xff; 263 params.seq = seq; 264 params.seq_len = 6; 265 break; 266 case ALG_CCMP: 267 params.cipher = WLAN_CIPHER_SUITE_CCMP; 268 seq[0] = key->u.ccmp.tx_pn[5]; 269 seq[1] = key->u.ccmp.tx_pn[4]; 270 seq[2] = key->u.ccmp.tx_pn[3]; 271 seq[3] = key->u.ccmp.tx_pn[2]; 272 seq[4] = key->u.ccmp.tx_pn[1]; 273 seq[5] = key->u.ccmp.tx_pn[0]; 274 params.seq = seq; 275 params.seq_len = 6; 276 break; 277 case ALG_WEP: 278 if (key->conf.keylen == 5) 279 params.cipher = WLAN_CIPHER_SUITE_WEP40; 280 else 281 params.cipher = WLAN_CIPHER_SUITE_WEP104; 282 break; 283 } 284 285 params.key = key->conf.key; 286 params.key_len = key->conf.keylen; 287 288 callback(cookie, ¶ms); 289 err = 0; 290 291 out: 292 rcu_read_unlock(); 293 return err; 294 } 295 296 static int ieee80211_config_default_key(struct wiphy *wiphy, 297 struct net_device *dev, 298 u8 key_idx) 299 { 300 struct ieee80211_sub_if_data *sdata; 301 302 rcu_read_lock(); 303 304 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 305 ieee80211_set_default_key(sdata, key_idx); 306 307 rcu_read_unlock(); 308 309 return 0; 310 } 311 312 static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo) 313 { 314 struct ieee80211_sub_if_data *sdata = sta->sdata; 315 316 sinfo->filled = STATION_INFO_INACTIVE_TIME | 317 STATION_INFO_RX_BYTES | 318 STATION_INFO_TX_BYTES; 319 320 sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx); 321 sinfo->rx_bytes = sta->rx_bytes; 322 sinfo->tx_bytes = sta->tx_bytes; 323 324 if (ieee80211_vif_is_mesh(&sdata->vif)) { 325 #ifdef CONFIG_MAC80211_MESH 326 sinfo->filled |= STATION_INFO_LLID | 327 STATION_INFO_PLID | 328 STATION_INFO_PLINK_STATE; 329 330 sinfo->llid = le16_to_cpu(sta->llid); 331 sinfo->plid = le16_to_cpu(sta->plid); 332 sinfo->plink_state = sta->plink_state; 333 #endif 334 } 335 } 336 337 338 static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev, 339 int idx, u8 *mac, struct station_info *sinfo) 340 { 341 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 342 struct sta_info *sta; 343 int ret = -ENOENT; 344 345 rcu_read_lock(); 346 347 sta = sta_info_get_by_idx(local, idx, dev); 348 if (sta) { 349 ret = 0; 350 memcpy(mac, sta->sta.addr, ETH_ALEN); 351 sta_set_sinfo(sta, sinfo); 352 } 353 354 rcu_read_unlock(); 355 356 return ret; 357 } 358 359 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev, 360 u8 *mac, struct station_info *sinfo) 361 { 362 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 363 struct sta_info *sta; 364 int ret = -ENOENT; 365 366 rcu_read_lock(); 367 368 /* XXX: verify sta->dev == dev */ 369 370 sta = sta_info_get(local, mac); 371 if (sta) { 372 ret = 0; 373 sta_set_sinfo(sta, sinfo); 374 } 375 376 rcu_read_unlock(); 377 378 return ret; 379 } 380 381 /* 382 * This handles both adding a beacon and setting new beacon info 383 */ 384 static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata, 385 struct beacon_parameters *params) 386 { 387 struct beacon_data *new, *old; 388 int new_head_len, new_tail_len; 389 int size; 390 int err = -EINVAL; 391 392 old = sdata->u.ap.beacon; 393 394 /* head must not be zero-length */ 395 if (params->head && !params->head_len) 396 return -EINVAL; 397 398 /* 399 * This is a kludge. beacon interval should really be part 400 * of the beacon information. 401 */ 402 if (params->interval) { 403 sdata->local->hw.conf.beacon_int = params->interval; 404 if (ieee80211_hw_config(sdata->local)) 405 return -EINVAL; 406 /* 407 * We updated some parameter so if below bails out 408 * it's not an error. 409 */ 410 err = 0; 411 } 412 413 /* Need to have a beacon head if we don't have one yet */ 414 if (!params->head && !old) 415 return err; 416 417 /* sorry, no way to start beaconing without dtim period */ 418 if (!params->dtim_period && !old) 419 return err; 420 421 /* new or old head? */ 422 if (params->head) 423 new_head_len = params->head_len; 424 else 425 new_head_len = old->head_len; 426 427 /* new or old tail? */ 428 if (params->tail || !old) 429 /* params->tail_len will be zero for !params->tail */ 430 new_tail_len = params->tail_len; 431 else 432 new_tail_len = old->tail_len; 433 434 size = sizeof(*new) + new_head_len + new_tail_len; 435 436 new = kzalloc(size, GFP_KERNEL); 437 if (!new) 438 return -ENOMEM; 439 440 /* start filling the new info now */ 441 442 /* new or old dtim period? */ 443 if (params->dtim_period) 444 new->dtim_period = params->dtim_period; 445 else 446 new->dtim_period = old->dtim_period; 447 448 /* 449 * pointers go into the block we allocated, 450 * memory is | beacon_data | head | tail | 451 */ 452 new->head = ((u8 *) new) + sizeof(*new); 453 new->tail = new->head + new_head_len; 454 new->head_len = new_head_len; 455 new->tail_len = new_tail_len; 456 457 /* copy in head */ 458 if (params->head) 459 memcpy(new->head, params->head, new_head_len); 460 else 461 memcpy(new->head, old->head, new_head_len); 462 463 /* copy in optional tail */ 464 if (params->tail) 465 memcpy(new->tail, params->tail, new_tail_len); 466 else 467 if (old) 468 memcpy(new->tail, old->tail, new_tail_len); 469 470 rcu_assign_pointer(sdata->u.ap.beacon, new); 471 472 synchronize_rcu(); 473 474 kfree(old); 475 476 return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON); 477 } 478 479 static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev, 480 struct beacon_parameters *params) 481 { 482 struct ieee80211_sub_if_data *sdata; 483 struct beacon_data *old; 484 485 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 486 487 if (sdata->vif.type != NL80211_IFTYPE_AP) 488 return -EINVAL; 489 490 old = sdata->u.ap.beacon; 491 492 if (old) 493 return -EALREADY; 494 495 return ieee80211_config_beacon(sdata, params); 496 } 497 498 static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev, 499 struct beacon_parameters *params) 500 { 501 struct ieee80211_sub_if_data *sdata; 502 struct beacon_data *old; 503 504 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 505 506 if (sdata->vif.type != NL80211_IFTYPE_AP) 507 return -EINVAL; 508 509 old = sdata->u.ap.beacon; 510 511 if (!old) 512 return -ENOENT; 513 514 return ieee80211_config_beacon(sdata, params); 515 } 516 517 static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev) 518 { 519 struct ieee80211_sub_if_data *sdata; 520 struct beacon_data *old; 521 522 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 523 524 if (sdata->vif.type != NL80211_IFTYPE_AP) 525 return -EINVAL; 526 527 old = sdata->u.ap.beacon; 528 529 if (!old) 530 return -ENOENT; 531 532 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 533 synchronize_rcu(); 534 kfree(old); 535 536 return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON); 537 } 538 539 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */ 540 struct iapp_layer2_update { 541 u8 da[ETH_ALEN]; /* broadcast */ 542 u8 sa[ETH_ALEN]; /* STA addr */ 543 __be16 len; /* 6 */ 544 u8 dsap; /* 0 */ 545 u8 ssap; /* 0 */ 546 u8 control; 547 u8 xid_info[3]; 548 } __attribute__ ((packed)); 549 550 static void ieee80211_send_layer2_update(struct sta_info *sta) 551 { 552 struct iapp_layer2_update *msg; 553 struct sk_buff *skb; 554 555 /* Send Level 2 Update Frame to update forwarding tables in layer 2 556 * bridge devices */ 557 558 skb = dev_alloc_skb(sizeof(*msg)); 559 if (!skb) 560 return; 561 msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg)); 562 563 /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID) 564 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */ 565 566 memset(msg->da, 0xff, ETH_ALEN); 567 memcpy(msg->sa, sta->sta.addr, ETH_ALEN); 568 msg->len = htons(6); 569 msg->dsap = 0; 570 msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */ 571 msg->control = 0xaf; /* XID response lsb.1111F101. 572 * F=0 (no poll command; unsolicited frame) */ 573 msg->xid_info[0] = 0x81; /* XID format identifier */ 574 msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */ 575 msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */ 576 577 skb->dev = sta->sdata->dev; 578 skb->protocol = eth_type_trans(skb, sta->sdata->dev); 579 memset(skb->cb, 0, sizeof(skb->cb)); 580 netif_rx(skb); 581 } 582 583 static void sta_apply_parameters(struct ieee80211_local *local, 584 struct sta_info *sta, 585 struct station_parameters *params) 586 { 587 u32 rates; 588 int i, j; 589 struct ieee80211_supported_band *sband; 590 struct ieee80211_sub_if_data *sdata = sta->sdata; 591 592 /* 593 * FIXME: updating the flags is racy when this function is 594 * called from ieee80211_change_station(), this will 595 * be resolved in a future patch. 596 */ 597 598 if (params->station_flags & STATION_FLAG_CHANGED) { 599 spin_lock_bh(&sta->lock); 600 sta->flags &= ~WLAN_STA_AUTHORIZED; 601 if (params->station_flags & STATION_FLAG_AUTHORIZED) 602 sta->flags |= WLAN_STA_AUTHORIZED; 603 604 sta->flags &= ~WLAN_STA_SHORT_PREAMBLE; 605 if (params->station_flags & STATION_FLAG_SHORT_PREAMBLE) 606 sta->flags |= WLAN_STA_SHORT_PREAMBLE; 607 608 sta->flags &= ~WLAN_STA_WME; 609 if (params->station_flags & STATION_FLAG_WME) 610 sta->flags |= WLAN_STA_WME; 611 spin_unlock_bh(&sta->lock); 612 } 613 614 /* 615 * FIXME: updating the following information is racy when this 616 * function is called from ieee80211_change_station(). 617 * However, all this information should be static so 618 * maybe we should just reject attemps to change it. 619 */ 620 621 if (params->aid) { 622 sta->sta.aid = params->aid; 623 if (sta->sta.aid > IEEE80211_MAX_AID) 624 sta->sta.aid = 0; /* XXX: should this be an error? */ 625 } 626 627 if (params->listen_interval >= 0) 628 sta->listen_interval = params->listen_interval; 629 630 if (params->supported_rates) { 631 rates = 0; 632 sband = local->hw.wiphy->bands[local->oper_channel->band]; 633 634 for (i = 0; i < params->supported_rates_len; i++) { 635 int rate = (params->supported_rates[i] & 0x7f) * 5; 636 for (j = 0; j < sband->n_bitrates; j++) { 637 if (sband->bitrates[j].bitrate == rate) 638 rates |= BIT(j); 639 } 640 } 641 sta->sta.supp_rates[local->oper_channel->band] = rates; 642 } 643 644 if (params->ht_capa) { 645 ieee80211_ht_cap_ie_to_ht_info(params->ht_capa, 646 &sta->sta.ht_info); 647 } 648 649 if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) { 650 switch (params->plink_action) { 651 case PLINK_ACTION_OPEN: 652 mesh_plink_open(sta); 653 break; 654 case PLINK_ACTION_BLOCK: 655 mesh_plink_block(sta); 656 break; 657 } 658 } 659 } 660 661 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev, 662 u8 *mac, struct station_parameters *params) 663 { 664 struct ieee80211_local *local = wiphy_priv(wiphy); 665 struct sta_info *sta; 666 struct ieee80211_sub_if_data *sdata; 667 int err; 668 669 /* Prevent a race with changing the rate control algorithm */ 670 if (!netif_running(dev)) 671 return -ENETDOWN; 672 673 if (params->vlan) { 674 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 675 676 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 677 sdata->vif.type != NL80211_IFTYPE_AP) 678 return -EINVAL; 679 } else 680 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 681 682 if (compare_ether_addr(mac, dev->dev_addr) == 0) 683 return -EINVAL; 684 685 if (is_multicast_ether_addr(mac)) 686 return -EINVAL; 687 688 sta = sta_info_alloc(sdata, mac, GFP_KERNEL); 689 if (!sta) 690 return -ENOMEM; 691 692 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC; 693 694 sta_apply_parameters(local, sta, params); 695 696 rate_control_rate_init(sta); 697 698 rcu_read_lock(); 699 700 err = sta_info_insert(sta); 701 if (err) { 702 /* STA has been freed */ 703 rcu_read_unlock(); 704 return err; 705 } 706 707 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN || 708 sdata->vif.type == NL80211_IFTYPE_AP) 709 ieee80211_send_layer2_update(sta); 710 711 rcu_read_unlock(); 712 713 return 0; 714 } 715 716 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev, 717 u8 *mac) 718 { 719 struct ieee80211_local *local = wiphy_priv(wiphy); 720 struct ieee80211_sub_if_data *sdata; 721 struct sta_info *sta; 722 723 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 724 725 if (mac) { 726 rcu_read_lock(); 727 728 /* XXX: get sta belonging to dev */ 729 sta = sta_info_get(local, mac); 730 if (!sta) { 731 rcu_read_unlock(); 732 return -ENOENT; 733 } 734 735 sta_info_unlink(&sta); 736 rcu_read_unlock(); 737 738 sta_info_destroy(sta); 739 } else 740 sta_info_flush(local, sdata); 741 742 return 0; 743 } 744 745 static int ieee80211_change_station(struct wiphy *wiphy, 746 struct net_device *dev, 747 u8 *mac, 748 struct station_parameters *params) 749 { 750 struct ieee80211_local *local = wiphy_priv(wiphy); 751 struct sta_info *sta; 752 struct ieee80211_sub_if_data *vlansdata; 753 754 rcu_read_lock(); 755 756 /* XXX: get sta belonging to dev */ 757 sta = sta_info_get(local, mac); 758 if (!sta) { 759 rcu_read_unlock(); 760 return -ENOENT; 761 } 762 763 if (params->vlan && params->vlan != sta->sdata->dev) { 764 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan); 765 766 if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN && 767 vlansdata->vif.type != NL80211_IFTYPE_AP) { 768 rcu_read_unlock(); 769 return -EINVAL; 770 } 771 772 sta->sdata = vlansdata; 773 ieee80211_send_layer2_update(sta); 774 } 775 776 sta_apply_parameters(local, sta, params); 777 778 rcu_read_unlock(); 779 780 return 0; 781 } 782 783 #ifdef CONFIG_MAC80211_MESH 784 static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev, 785 u8 *dst, u8 *next_hop) 786 { 787 struct ieee80211_local *local = wiphy_priv(wiphy); 788 struct ieee80211_sub_if_data *sdata; 789 struct mesh_path *mpath; 790 struct sta_info *sta; 791 int err; 792 793 if (!netif_running(dev)) 794 return -ENETDOWN; 795 796 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 797 798 if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT) 799 return -ENOTSUPP; 800 801 rcu_read_lock(); 802 sta = sta_info_get(local, next_hop); 803 if (!sta) { 804 rcu_read_unlock(); 805 return -ENOENT; 806 } 807 808 err = mesh_path_add(dst, sdata); 809 if (err) { 810 rcu_read_unlock(); 811 return err; 812 } 813 814 mpath = mesh_path_lookup(dst, sdata); 815 if (!mpath) { 816 rcu_read_unlock(); 817 return -ENXIO; 818 } 819 mesh_path_fix_nexthop(mpath, sta); 820 821 rcu_read_unlock(); 822 return 0; 823 } 824 825 static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev, 826 u8 *dst) 827 { 828 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 829 830 if (dst) 831 return mesh_path_del(dst, sdata); 832 833 mesh_path_flush(sdata); 834 return 0; 835 } 836 837 static int ieee80211_change_mpath(struct wiphy *wiphy, 838 struct net_device *dev, 839 u8 *dst, u8 *next_hop) 840 { 841 struct ieee80211_local *local = wiphy_priv(wiphy); 842 struct ieee80211_sub_if_data *sdata; 843 struct mesh_path *mpath; 844 struct sta_info *sta; 845 846 if (!netif_running(dev)) 847 return -ENETDOWN; 848 849 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 850 851 if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT) 852 return -ENOTSUPP; 853 854 rcu_read_lock(); 855 856 sta = sta_info_get(local, next_hop); 857 if (!sta) { 858 rcu_read_unlock(); 859 return -ENOENT; 860 } 861 862 mpath = mesh_path_lookup(dst, sdata); 863 if (!mpath) { 864 rcu_read_unlock(); 865 return -ENOENT; 866 } 867 868 mesh_path_fix_nexthop(mpath, sta); 869 870 rcu_read_unlock(); 871 return 0; 872 } 873 874 static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop, 875 struct mpath_info *pinfo) 876 { 877 if (mpath->next_hop) 878 memcpy(next_hop, mpath->next_hop->sta.addr, ETH_ALEN); 879 else 880 memset(next_hop, 0, ETH_ALEN); 881 882 pinfo->filled = MPATH_INFO_FRAME_QLEN | 883 MPATH_INFO_DSN | 884 MPATH_INFO_METRIC | 885 MPATH_INFO_EXPTIME | 886 MPATH_INFO_DISCOVERY_TIMEOUT | 887 MPATH_INFO_DISCOVERY_RETRIES | 888 MPATH_INFO_FLAGS; 889 890 pinfo->frame_qlen = mpath->frame_queue.qlen; 891 pinfo->dsn = mpath->dsn; 892 pinfo->metric = mpath->metric; 893 if (time_before(jiffies, mpath->exp_time)) 894 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies); 895 pinfo->discovery_timeout = 896 jiffies_to_msecs(mpath->discovery_timeout); 897 pinfo->discovery_retries = mpath->discovery_retries; 898 pinfo->flags = 0; 899 if (mpath->flags & MESH_PATH_ACTIVE) 900 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE; 901 if (mpath->flags & MESH_PATH_RESOLVING) 902 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 903 if (mpath->flags & MESH_PATH_DSN_VALID) 904 pinfo->flags |= NL80211_MPATH_FLAG_DSN_VALID; 905 if (mpath->flags & MESH_PATH_FIXED) 906 pinfo->flags |= NL80211_MPATH_FLAG_FIXED; 907 if (mpath->flags & MESH_PATH_RESOLVING) 908 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING; 909 910 pinfo->flags = mpath->flags; 911 } 912 913 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev, 914 u8 *dst, u8 *next_hop, struct mpath_info *pinfo) 915 916 { 917 struct ieee80211_sub_if_data *sdata; 918 struct mesh_path *mpath; 919 920 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 921 922 if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT) 923 return -ENOTSUPP; 924 925 rcu_read_lock(); 926 mpath = mesh_path_lookup(dst, sdata); 927 if (!mpath) { 928 rcu_read_unlock(); 929 return -ENOENT; 930 } 931 memcpy(dst, mpath->dst, ETH_ALEN); 932 mpath_set_pinfo(mpath, next_hop, pinfo); 933 rcu_read_unlock(); 934 return 0; 935 } 936 937 static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev, 938 int idx, u8 *dst, u8 *next_hop, 939 struct mpath_info *pinfo) 940 { 941 struct ieee80211_sub_if_data *sdata; 942 struct mesh_path *mpath; 943 944 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 945 946 if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT) 947 return -ENOTSUPP; 948 949 rcu_read_lock(); 950 mpath = mesh_path_lookup_by_idx(idx, sdata); 951 if (!mpath) { 952 rcu_read_unlock(); 953 return -ENOENT; 954 } 955 memcpy(dst, mpath->dst, ETH_ALEN); 956 mpath_set_pinfo(mpath, next_hop, pinfo); 957 rcu_read_unlock(); 958 return 0; 959 } 960 #endif 961 962 static int ieee80211_change_bss(struct wiphy *wiphy, 963 struct net_device *dev, 964 struct bss_parameters *params) 965 { 966 struct ieee80211_sub_if_data *sdata; 967 u32 changed = 0; 968 969 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 970 971 if (sdata->vif.type != NL80211_IFTYPE_AP) 972 return -EINVAL; 973 974 if (params->use_cts_prot >= 0) { 975 sdata->bss_conf.use_cts_prot = params->use_cts_prot; 976 changed |= BSS_CHANGED_ERP_CTS_PROT; 977 } 978 if (params->use_short_preamble >= 0) { 979 sdata->bss_conf.use_short_preamble = 980 params->use_short_preamble; 981 changed |= BSS_CHANGED_ERP_PREAMBLE; 982 } 983 if (params->use_short_slot_time >= 0) { 984 sdata->bss_conf.use_short_slot = 985 params->use_short_slot_time; 986 changed |= BSS_CHANGED_ERP_SLOT; 987 } 988 989 ieee80211_bss_info_change_notify(sdata, changed); 990 991 return 0; 992 } 993 994 struct cfg80211_ops mac80211_config_ops = { 995 .add_virtual_intf = ieee80211_add_iface, 996 .del_virtual_intf = ieee80211_del_iface, 997 .change_virtual_intf = ieee80211_change_iface, 998 .add_key = ieee80211_add_key, 999 .del_key = ieee80211_del_key, 1000 .get_key = ieee80211_get_key, 1001 .set_default_key = ieee80211_config_default_key, 1002 .add_beacon = ieee80211_add_beacon, 1003 .set_beacon = ieee80211_set_beacon, 1004 .del_beacon = ieee80211_del_beacon, 1005 .add_station = ieee80211_add_station, 1006 .del_station = ieee80211_del_station, 1007 .change_station = ieee80211_change_station, 1008 .get_station = ieee80211_get_station, 1009 .dump_station = ieee80211_dump_station, 1010 #ifdef CONFIG_MAC80211_MESH 1011 .add_mpath = ieee80211_add_mpath, 1012 .del_mpath = ieee80211_del_mpath, 1013 .change_mpath = ieee80211_change_mpath, 1014 .get_mpath = ieee80211_get_mpath, 1015 .dump_mpath = ieee80211_dump_mpath, 1016 #endif 1017 .change_bss = ieee80211_change_bss, 1018 }; 1019