1 /* 2 * Interface handling (except master interface) 3 * 4 * Copyright 2002-2005, Instant802 Networks, Inc. 5 * Copyright 2005-2006, Devicescape Software, Inc. 6 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz> 7 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 #include <linux/kernel.h> 14 #include <linux/if_arp.h> 15 #include <linux/netdevice.h> 16 #include <linux/rtnetlink.h> 17 #include <net/mac80211.h> 18 #include "ieee80211_i.h" 19 #include "sta_info.h" 20 #include "debugfs_netdev.h" 21 #include "mesh.h" 22 #include "led.h" 23 24 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu) 25 { 26 int meshhdrlen; 27 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 28 29 meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0; 30 31 /* FIX: what would be proper limits for MTU? 32 * This interface uses 802.3 frames. */ 33 if (new_mtu < 256 || 34 new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) { 35 return -EINVAL; 36 } 37 38 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 39 printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu); 40 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 41 dev->mtu = new_mtu; 42 return 0; 43 } 44 45 static inline int identical_mac_addr_allowed(int type1, int type2) 46 { 47 return type1 == NL80211_IFTYPE_MONITOR || 48 type2 == NL80211_IFTYPE_MONITOR || 49 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) || 50 (type1 == NL80211_IFTYPE_WDS && 51 (type2 == NL80211_IFTYPE_WDS || 52 type2 == NL80211_IFTYPE_AP)) || 53 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) || 54 (type1 == NL80211_IFTYPE_AP_VLAN && 55 (type2 == NL80211_IFTYPE_AP || 56 type2 == NL80211_IFTYPE_AP_VLAN)); 57 } 58 59 static int ieee80211_open(struct net_device *dev) 60 { 61 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 62 struct ieee80211_sub_if_data *nsdata; 63 struct ieee80211_local *local = sdata->local; 64 struct sta_info *sta; 65 struct ieee80211_if_init_conf conf; 66 u32 changed = 0; 67 int res; 68 bool need_hw_reconfig = 0; 69 u8 null_addr[ETH_ALEN] = {0}; 70 71 /* fail early if user set an invalid address */ 72 if (compare_ether_addr(dev->dev_addr, null_addr) && 73 !is_valid_ether_addr(dev->dev_addr)) 74 return -EADDRNOTAVAIL; 75 76 /* we hold the RTNL here so can safely walk the list */ 77 list_for_each_entry(nsdata, &local->interfaces, list) { 78 struct net_device *ndev = nsdata->dev; 79 80 if (ndev != dev && netif_running(ndev)) { 81 /* 82 * Allow only a single IBSS interface to be up at any 83 * time. This is restricted because beacon distribution 84 * cannot work properly if both are in the same IBSS. 85 * 86 * To remove this restriction we'd have to disallow them 87 * from setting the same SSID on different IBSS interfaces 88 * belonging to the same hardware. Then, however, we're 89 * faced with having to adopt two different TSF timers... 90 */ 91 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && 92 nsdata->vif.type == NL80211_IFTYPE_ADHOC) 93 return -EBUSY; 94 95 /* 96 * The remaining checks are only performed for interfaces 97 * with the same MAC address. 98 */ 99 if (compare_ether_addr(dev->dev_addr, ndev->dev_addr)) 100 continue; 101 102 /* 103 * check whether it may have the same address 104 */ 105 if (!identical_mac_addr_allowed(sdata->vif.type, 106 nsdata->vif.type)) 107 return -ENOTUNIQ; 108 109 /* 110 * can only add VLANs to enabled APs 111 */ 112 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN && 113 nsdata->vif.type == NL80211_IFTYPE_AP) 114 sdata->bss = &nsdata->u.ap; 115 } 116 } 117 118 switch (sdata->vif.type) { 119 case NL80211_IFTYPE_WDS: 120 if (!is_valid_ether_addr(sdata->u.wds.remote_addr)) 121 return -ENOLINK; 122 break; 123 case NL80211_IFTYPE_AP_VLAN: 124 if (!sdata->bss) 125 return -ENOLINK; 126 list_add(&sdata->u.vlan.list, &sdata->bss->vlans); 127 break; 128 case NL80211_IFTYPE_AP: 129 sdata->bss = &sdata->u.ap; 130 break; 131 case NL80211_IFTYPE_MESH_POINT: 132 if (!ieee80211_vif_is_mesh(&sdata->vif)) 133 break; 134 /* mesh ifaces must set allmulti to forward mcast traffic */ 135 atomic_inc(&local->iff_allmultis); 136 break; 137 case NL80211_IFTYPE_STATION: 138 case NL80211_IFTYPE_MONITOR: 139 case NL80211_IFTYPE_ADHOC: 140 /* no special treatment */ 141 break; 142 case NL80211_IFTYPE_UNSPECIFIED: 143 case __NL80211_IFTYPE_AFTER_LAST: 144 /* cannot happen */ 145 WARN_ON(1); 146 break; 147 } 148 149 if (local->open_count == 0) { 150 res = 0; 151 if (local->ops->start) 152 res = local->ops->start(local_to_hw(local)); 153 if (res) 154 goto err_del_bss; 155 need_hw_reconfig = 1; 156 ieee80211_led_radio(local, local->hw.conf.radio_enabled); 157 } 158 159 /* 160 * Check all interfaces and copy the hopefully now-present 161 * MAC address to those that have the special null one. 162 */ 163 list_for_each_entry(nsdata, &local->interfaces, list) { 164 struct net_device *ndev = nsdata->dev; 165 166 /* 167 * No need to check netif_running since we do not allow 168 * it to start up with this invalid address. 169 */ 170 if (compare_ether_addr(null_addr, ndev->dev_addr) == 0) 171 memcpy(ndev->dev_addr, 172 local->hw.wiphy->perm_addr, 173 ETH_ALEN); 174 } 175 176 if (compare_ether_addr(null_addr, local->mdev->dev_addr) == 0) 177 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, 178 ETH_ALEN); 179 180 /* 181 * Validate the MAC address for this device. 182 */ 183 if (!is_valid_ether_addr(dev->dev_addr)) { 184 if (!local->open_count && local->ops->stop) 185 local->ops->stop(local_to_hw(local)); 186 return -EADDRNOTAVAIL; 187 } 188 189 switch (sdata->vif.type) { 190 case NL80211_IFTYPE_AP_VLAN: 191 /* no need to tell driver */ 192 break; 193 case NL80211_IFTYPE_MONITOR: 194 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 195 local->cooked_mntrs++; 196 break; 197 } 198 199 /* must be before the call to ieee80211_configure_filter */ 200 local->monitors++; 201 if (local->monitors == 1) 202 local->hw.conf.flags |= IEEE80211_CONF_RADIOTAP; 203 204 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 205 local->fif_fcsfail++; 206 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 207 local->fif_plcpfail++; 208 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 209 local->fif_control++; 210 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 211 local->fif_other_bss++; 212 213 netif_addr_lock_bh(local->mdev); 214 ieee80211_configure_filter(local); 215 netif_addr_unlock_bh(local->mdev); 216 break; 217 case NL80211_IFTYPE_STATION: 218 case NL80211_IFTYPE_ADHOC: 219 sdata->u.sta.flags &= ~IEEE80211_STA_PREV_BSSID_SET; 220 /* fall through */ 221 default: 222 conf.vif = &sdata->vif; 223 conf.type = sdata->vif.type; 224 conf.mac_addr = dev->dev_addr; 225 res = local->ops->add_interface(local_to_hw(local), &conf); 226 if (res) 227 goto err_stop; 228 229 if (ieee80211_vif_is_mesh(&sdata->vif)) 230 ieee80211_start_mesh(sdata); 231 changed |= ieee80211_reset_erp_info(sdata); 232 ieee80211_bss_info_change_notify(sdata, changed); 233 ieee80211_enable_keys(sdata); 234 235 if (sdata->vif.type == NL80211_IFTYPE_STATION && 236 !(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)) 237 netif_carrier_off(dev); 238 else 239 netif_carrier_on(dev); 240 } 241 242 if (sdata->vif.type == NL80211_IFTYPE_WDS) { 243 /* Create STA entry for the WDS peer */ 244 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, 245 GFP_KERNEL); 246 if (!sta) { 247 res = -ENOMEM; 248 goto err_del_interface; 249 } 250 251 /* no locking required since STA is not live yet */ 252 sta->flags |= WLAN_STA_AUTHORIZED; 253 254 res = sta_info_insert(sta); 255 if (res) { 256 /* STA has been freed */ 257 goto err_del_interface; 258 } 259 } 260 261 if (local->open_count == 0) { 262 res = dev_open(local->mdev); 263 WARN_ON(res); 264 if (res) 265 goto err_del_interface; 266 tasklet_enable(&local->tx_pending_tasklet); 267 tasklet_enable(&local->tasklet); 268 } 269 270 /* 271 * set_multicast_list will be invoked by the networking core 272 * which will check whether any increments here were done in 273 * error and sync them down to the hardware as filter flags. 274 */ 275 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 276 atomic_inc(&local->iff_allmultis); 277 278 if (sdata->flags & IEEE80211_SDATA_PROMISC) 279 atomic_inc(&local->iff_promiscs); 280 281 local->open_count++; 282 if (need_hw_reconfig) { 283 ieee80211_hw_config(local); 284 /* 285 * set default queue parameters so drivers don't 286 * need to initialise the hardware if the hardware 287 * doesn't start up with sane defaults 288 */ 289 ieee80211_set_wmm_default(sdata); 290 } 291 292 /* 293 * ieee80211_sta_work is disabled while network interface 294 * is down. Therefore, some configuration changes may not 295 * yet be effective. Trigger execution of ieee80211_sta_work 296 * to fix this. 297 */ 298 if (sdata->vif.type == NL80211_IFTYPE_STATION || 299 sdata->vif.type == NL80211_IFTYPE_ADHOC) { 300 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 301 queue_work(local->hw.workqueue, &ifsta->work); 302 } 303 304 netif_tx_start_all_queues(dev); 305 306 return 0; 307 err_del_interface: 308 local->ops->remove_interface(local_to_hw(local), &conf); 309 err_stop: 310 if (!local->open_count && local->ops->stop) 311 local->ops->stop(local_to_hw(local)); 312 err_del_bss: 313 sdata->bss = NULL; 314 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 315 list_del(&sdata->u.vlan.list); 316 return res; 317 } 318 319 static int ieee80211_stop(struct net_device *dev) 320 { 321 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 322 struct ieee80211_local *local = sdata->local; 323 struct ieee80211_if_init_conf conf; 324 struct sta_info *sta; 325 326 /* 327 * Stop TX on this interface first. 328 */ 329 netif_tx_stop_all_queues(dev); 330 331 /* 332 * Now delete all active aggregation sessions. 333 */ 334 rcu_read_lock(); 335 336 list_for_each_entry_rcu(sta, &local->sta_list, list) { 337 if (sta->sdata == sdata) 338 ieee80211_sta_tear_down_BA_sessions(sdata, 339 sta->sta.addr); 340 } 341 342 rcu_read_unlock(); 343 344 /* 345 * Remove all stations associated with this interface. 346 * 347 * This must be done before calling ops->remove_interface() 348 * because otherwise we can later invoke ops->sta_notify() 349 * whenever the STAs are removed, and that invalidates driver 350 * assumptions about always getting a vif pointer that is valid 351 * (because if we remove a STA after ops->remove_interface() 352 * the driver will have removed the vif info already!) 353 * 354 * We could relax this and only unlink the stations from the 355 * hash table and list but keep them on a per-sdata list that 356 * will be inserted back again when the interface is brought 357 * up again, but I don't currently see a use case for that, 358 * except with WDS which gets a STA entry created when it is 359 * brought up. 360 */ 361 sta_info_flush(local, sdata); 362 363 /* 364 * Don't count this interface for promisc/allmulti while it 365 * is down. dev_mc_unsync() will invoke set_multicast_list 366 * on the master interface which will sync these down to the 367 * hardware as filter flags. 368 */ 369 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 370 atomic_dec(&local->iff_allmultis); 371 372 if (sdata->flags & IEEE80211_SDATA_PROMISC) 373 atomic_dec(&local->iff_promiscs); 374 375 dev_mc_unsync(local->mdev, dev); 376 377 /* APs need special treatment */ 378 if (sdata->vif.type == NL80211_IFTYPE_AP) { 379 struct ieee80211_sub_if_data *vlan, *tmp; 380 struct beacon_data *old_beacon = sdata->u.ap.beacon; 381 382 /* remove beacon */ 383 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 384 synchronize_rcu(); 385 kfree(old_beacon); 386 387 /* down all dependent devices, that is VLANs */ 388 list_for_each_entry_safe(vlan, tmp, &sdata->u.ap.vlans, 389 u.vlan.list) 390 dev_close(vlan->dev); 391 WARN_ON(!list_empty(&sdata->u.ap.vlans)); 392 } 393 394 local->open_count--; 395 396 switch (sdata->vif.type) { 397 case NL80211_IFTYPE_AP_VLAN: 398 list_del(&sdata->u.vlan.list); 399 /* no need to tell driver */ 400 break; 401 case NL80211_IFTYPE_MONITOR: 402 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 403 local->cooked_mntrs--; 404 break; 405 } 406 407 local->monitors--; 408 if (local->monitors == 0) 409 local->hw.conf.flags &= ~IEEE80211_CONF_RADIOTAP; 410 411 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 412 local->fif_fcsfail--; 413 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 414 local->fif_plcpfail--; 415 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 416 local->fif_control--; 417 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 418 local->fif_other_bss--; 419 420 netif_addr_lock_bh(local->mdev); 421 ieee80211_configure_filter(local); 422 netif_addr_unlock_bh(local->mdev); 423 break; 424 case NL80211_IFTYPE_STATION: 425 case NL80211_IFTYPE_ADHOC: 426 sdata->u.sta.state = IEEE80211_STA_MLME_DISABLED; 427 memset(sdata->u.sta.bssid, 0, ETH_ALEN); 428 del_timer_sync(&sdata->u.sta.timer); 429 /* 430 * If the timer fired while we waited for it, it will have 431 * requeued the work. Now the work will be running again 432 * but will not rearm the timer again because it checks 433 * whether the interface is running, which, at this point, 434 * it no longer is. 435 */ 436 cancel_work_sync(&sdata->u.sta.work); 437 /* 438 * When we get here, the interface is marked down. 439 * Call synchronize_rcu() to wait for the RX path 440 * should it be using the interface and enqueuing 441 * frames at this very time on another CPU. 442 */ 443 synchronize_rcu(); 444 skb_queue_purge(&sdata->u.sta.skb_queue); 445 446 sdata->u.sta.flags &= ~IEEE80211_STA_PRIVACY_INVOKED; 447 kfree(sdata->u.sta.extra_ie); 448 sdata->u.sta.extra_ie = NULL; 449 sdata->u.sta.extra_ie_len = 0; 450 /* fall through */ 451 case NL80211_IFTYPE_MESH_POINT: 452 if (ieee80211_vif_is_mesh(&sdata->vif)) { 453 /* allmulti is always set on mesh ifaces */ 454 atomic_dec(&local->iff_allmultis); 455 ieee80211_stop_mesh(sdata); 456 } 457 /* fall through */ 458 default: 459 if (local->scan_sdata == sdata) { 460 if (!local->ops->hw_scan) 461 cancel_delayed_work_sync(&local->scan_work); 462 /* 463 * The software scan can no longer run now, so we can 464 * clear out the scan_sdata reference. However, the 465 * hardware scan may still be running. The complete 466 * function must be prepared to handle a NULL value. 467 */ 468 local->scan_sdata = NULL; 469 /* 470 * The memory barrier guarantees that another CPU 471 * that is hardware-scanning will now see the fact 472 * that this interface is gone. 473 */ 474 smp_mb(); 475 /* 476 * If software scanning, complete the scan but since 477 * the scan_sdata is NULL already don't send out a 478 * scan event to userspace -- the scan is incomplete. 479 */ 480 if (local->sw_scanning) 481 ieee80211_scan_completed(&local->hw); 482 } 483 484 conf.vif = &sdata->vif; 485 conf.type = sdata->vif.type; 486 conf.mac_addr = dev->dev_addr; 487 /* disable all keys for as long as this netdev is down */ 488 ieee80211_disable_keys(sdata); 489 local->ops->remove_interface(local_to_hw(local), &conf); 490 } 491 492 sdata->bss = NULL; 493 494 if (local->open_count == 0) { 495 if (netif_running(local->mdev)) 496 dev_close(local->mdev); 497 498 if (local->ops->stop) 499 local->ops->stop(local_to_hw(local)); 500 501 ieee80211_led_radio(local, 0); 502 503 flush_workqueue(local->hw.workqueue); 504 505 tasklet_disable(&local->tx_pending_tasklet); 506 tasklet_disable(&local->tasklet); 507 } 508 509 return 0; 510 } 511 512 static void ieee80211_set_multicast_list(struct net_device *dev) 513 { 514 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 515 struct ieee80211_local *local = sdata->local; 516 int allmulti, promisc, sdata_allmulti, sdata_promisc; 517 518 allmulti = !!(dev->flags & IFF_ALLMULTI); 519 promisc = !!(dev->flags & IFF_PROMISC); 520 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI); 521 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC); 522 523 if (allmulti != sdata_allmulti) { 524 if (dev->flags & IFF_ALLMULTI) 525 atomic_inc(&local->iff_allmultis); 526 else 527 atomic_dec(&local->iff_allmultis); 528 sdata->flags ^= IEEE80211_SDATA_ALLMULTI; 529 } 530 531 if (promisc != sdata_promisc) { 532 if (dev->flags & IFF_PROMISC) 533 atomic_inc(&local->iff_promiscs); 534 else 535 atomic_dec(&local->iff_promiscs); 536 sdata->flags ^= IEEE80211_SDATA_PROMISC; 537 } 538 539 dev_mc_sync(local->mdev, dev); 540 } 541 542 static void ieee80211_if_setup(struct net_device *dev) 543 { 544 ether_setup(dev); 545 dev->hard_start_xmit = ieee80211_subif_start_xmit; 546 dev->wireless_handlers = &ieee80211_iw_handler_def; 547 dev->set_multicast_list = ieee80211_set_multicast_list; 548 dev->change_mtu = ieee80211_change_mtu; 549 dev->open = ieee80211_open; 550 dev->stop = ieee80211_stop; 551 dev->destructor = free_netdev; 552 /* we will validate the address ourselves in ->open */ 553 dev->validate_addr = NULL; 554 } 555 /* 556 * Called when the netdev is removed or, by the code below, before 557 * the interface type changes. 558 */ 559 static void ieee80211_teardown_sdata(struct net_device *dev) 560 { 561 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 562 struct ieee80211_local *local = sdata->local; 563 struct beacon_data *beacon; 564 struct sk_buff *skb; 565 int flushed; 566 int i; 567 568 /* free extra data */ 569 ieee80211_free_keys(sdata); 570 571 ieee80211_debugfs_remove_netdev(sdata); 572 573 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 574 __skb_queue_purge(&sdata->fragments[i].skb_list); 575 sdata->fragment_next = 0; 576 577 switch (sdata->vif.type) { 578 case NL80211_IFTYPE_AP: 579 beacon = sdata->u.ap.beacon; 580 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 581 synchronize_rcu(); 582 kfree(beacon); 583 584 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) { 585 local->total_ps_buffered--; 586 dev_kfree_skb(skb); 587 } 588 589 break; 590 case NL80211_IFTYPE_MESH_POINT: 591 if (ieee80211_vif_is_mesh(&sdata->vif)) 592 mesh_rmc_free(sdata); 593 break; 594 case NL80211_IFTYPE_STATION: 595 case NL80211_IFTYPE_ADHOC: 596 kfree(sdata->u.sta.extra_ie); 597 kfree(sdata->u.sta.assocreq_ies); 598 kfree(sdata->u.sta.assocresp_ies); 599 kfree_skb(sdata->u.sta.probe_resp); 600 break; 601 case NL80211_IFTYPE_WDS: 602 case NL80211_IFTYPE_AP_VLAN: 603 case NL80211_IFTYPE_MONITOR: 604 break; 605 case NL80211_IFTYPE_UNSPECIFIED: 606 case __NL80211_IFTYPE_AFTER_LAST: 607 BUG(); 608 break; 609 } 610 611 flushed = sta_info_flush(local, sdata); 612 WARN_ON(flushed); 613 } 614 615 /* 616 * Helper function to initialise an interface to a specific type. 617 */ 618 static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata, 619 enum nl80211_iftype type) 620 { 621 /* clear type-dependent union */ 622 memset(&sdata->u, 0, sizeof(sdata->u)); 623 624 /* and set some type-dependent values */ 625 sdata->vif.type = type; 626 sdata->dev->hard_start_xmit = ieee80211_subif_start_xmit; 627 sdata->wdev.iftype = type; 628 629 /* only monitor differs */ 630 sdata->dev->type = ARPHRD_ETHER; 631 632 switch (type) { 633 case NL80211_IFTYPE_AP: 634 skb_queue_head_init(&sdata->u.ap.ps_bc_buf); 635 INIT_LIST_HEAD(&sdata->u.ap.vlans); 636 break; 637 case NL80211_IFTYPE_STATION: 638 case NL80211_IFTYPE_ADHOC: 639 ieee80211_sta_setup_sdata(sdata); 640 break; 641 case NL80211_IFTYPE_MESH_POINT: 642 if (ieee80211_vif_is_mesh(&sdata->vif)) 643 ieee80211_mesh_init_sdata(sdata); 644 break; 645 case NL80211_IFTYPE_MONITOR: 646 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP; 647 sdata->dev->hard_start_xmit = ieee80211_monitor_start_xmit; 648 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL | 649 MONITOR_FLAG_OTHER_BSS; 650 break; 651 case NL80211_IFTYPE_WDS: 652 case NL80211_IFTYPE_AP_VLAN: 653 break; 654 case NL80211_IFTYPE_UNSPECIFIED: 655 case __NL80211_IFTYPE_AFTER_LAST: 656 BUG(); 657 break; 658 } 659 660 ieee80211_debugfs_add_netdev(sdata); 661 } 662 663 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata, 664 enum nl80211_iftype type) 665 { 666 ASSERT_RTNL(); 667 668 if (type == sdata->vif.type) 669 return 0; 670 671 /* 672 * We could, here, on changes between IBSS/STA/MESH modes, 673 * invoke an MLME function instead that disassociates etc. 674 * and goes into the requested mode. 675 */ 676 677 if (netif_running(sdata->dev)) 678 return -EBUSY; 679 680 /* Purge and reset type-dependent state. */ 681 ieee80211_teardown_sdata(sdata->dev); 682 ieee80211_setup_sdata(sdata, type); 683 684 /* reset some values that shouldn't be kept across type changes */ 685 sdata->bss_conf.basic_rates = 686 ieee80211_mandatory_rates(sdata->local, 687 sdata->local->hw.conf.channel->band); 688 sdata->drop_unencrypted = 0; 689 690 return 0; 691 } 692 693 int ieee80211_if_add(struct ieee80211_local *local, const char *name, 694 struct net_device **new_dev, enum nl80211_iftype type, 695 struct vif_params *params) 696 { 697 struct net_device *ndev; 698 struct ieee80211_sub_if_data *sdata = NULL; 699 int ret, i; 700 701 ASSERT_RTNL(); 702 703 ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size, 704 name, ieee80211_if_setup); 705 if (!ndev) 706 return -ENOMEM; 707 708 ndev->needed_headroom = local->tx_headroom + 709 4*6 /* four MAC addresses */ 710 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */ 711 + 6 /* mesh */ 712 + 8 /* rfc1042/bridge tunnel */ 713 - ETH_HLEN /* ethernet hard_header_len */ 714 + IEEE80211_ENCRYPT_HEADROOM; 715 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM; 716 717 ret = dev_alloc_name(ndev, ndev->name); 718 if (ret < 0) 719 goto fail; 720 721 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 722 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy)); 723 724 /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */ 725 sdata = netdev_priv(ndev); 726 ndev->ieee80211_ptr = &sdata->wdev; 727 728 /* initialise type-independent data */ 729 sdata->wdev.wiphy = local->hw.wiphy; 730 sdata->local = local; 731 sdata->dev = ndev; 732 733 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 734 skb_queue_head_init(&sdata->fragments[i].skb_list); 735 736 INIT_LIST_HEAD(&sdata->key_list); 737 738 sdata->force_unicast_rateidx = -1; 739 sdata->max_ratectrl_rateidx = -1; 740 741 /* setup type-dependent data */ 742 ieee80211_setup_sdata(sdata, type); 743 744 ret = register_netdevice(ndev); 745 if (ret) 746 goto fail; 747 748 ndev->uninit = ieee80211_teardown_sdata; 749 750 if (ieee80211_vif_is_mesh(&sdata->vif) && 751 params && params->mesh_id_len) 752 ieee80211_sdata_set_mesh_id(sdata, 753 params->mesh_id_len, 754 params->mesh_id); 755 756 list_add_tail_rcu(&sdata->list, &local->interfaces); 757 758 if (new_dev) 759 *new_dev = ndev; 760 761 return 0; 762 763 fail: 764 free_netdev(ndev); 765 return ret; 766 } 767 768 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata) 769 { 770 ASSERT_RTNL(); 771 772 list_del_rcu(&sdata->list); 773 synchronize_rcu(); 774 unregister_netdevice(sdata->dev); 775 } 776 777 /* 778 * Remove all interfaces, may only be called at hardware unregistration 779 * time because it doesn't do RCU-safe list removals. 780 */ 781 void ieee80211_remove_interfaces(struct ieee80211_local *local) 782 { 783 struct ieee80211_sub_if_data *sdata, *tmp; 784 785 ASSERT_RTNL(); 786 787 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) { 788 list_del(&sdata->list); 789 unregister_netdevice(sdata->dev); 790 } 791 } 792