1 /* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 #include <linux/kernel.h> 11 #include <linux/if_arp.h> 12 #include <linux/netdevice.h> 13 #include <linux/rtnetlink.h> 14 #include <net/mac80211.h> 15 #include "ieee80211_i.h" 16 #include "sta_info.h" 17 #include "debugfs_netdev.h" 18 #include "mesh.h" 19 20 void ieee80211_if_sdata_init(struct ieee80211_sub_if_data *sdata) 21 { 22 int i; 23 24 /* Default values for sub-interface parameters */ 25 sdata->drop_unencrypted = 0; 26 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 27 skb_queue_head_init(&sdata->fragments[i].skb_list); 28 29 INIT_LIST_HEAD(&sdata->key_list); 30 } 31 32 static void ieee80211_if_sdata_deinit(struct ieee80211_sub_if_data *sdata) 33 { 34 int i; 35 36 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) { 37 __skb_queue_purge(&sdata->fragments[i].skb_list); 38 } 39 } 40 41 /* Must be called with rtnl lock held. */ 42 int ieee80211_if_add(struct net_device *dev, const char *name, 43 struct net_device **new_dev, int type, 44 struct vif_params *params) 45 { 46 struct net_device *ndev; 47 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 48 struct ieee80211_sub_if_data *sdata = NULL; 49 int ret; 50 51 ASSERT_RTNL(); 52 ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size, 53 name, ieee80211_if_setup); 54 if (!ndev) 55 return -ENOMEM; 56 57 ndev->needed_headroom = local->tx_headroom + 58 4*6 /* four MAC addresses */ 59 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */ 60 + 6 /* mesh */ 61 + 8 /* rfc1042/bridge tunnel */ 62 - ETH_HLEN /* ethernet hard_header_len */ 63 + IEEE80211_ENCRYPT_HEADROOM; 64 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM; 65 66 ret = dev_alloc_name(ndev, ndev->name); 67 if (ret < 0) 68 goto fail; 69 70 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 71 ndev->base_addr = dev->base_addr; 72 ndev->irq = dev->irq; 73 ndev->mem_start = dev->mem_start; 74 ndev->mem_end = dev->mem_end; 75 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy)); 76 77 sdata = IEEE80211_DEV_TO_SUB_IF(ndev); 78 ndev->ieee80211_ptr = &sdata->wdev; 79 sdata->wdev.wiphy = local->hw.wiphy; 80 sdata->vif.type = IEEE80211_IF_TYPE_AP; 81 sdata->dev = ndev; 82 sdata->local = local; 83 ieee80211_if_sdata_init(sdata); 84 85 ret = register_netdevice(ndev); 86 if (ret) 87 goto fail; 88 89 ieee80211_debugfs_add_netdev(sdata); 90 ieee80211_if_set_type(ndev, type); 91 92 if (ieee80211_vif_is_mesh(&sdata->vif) && 93 params && params->mesh_id_len) 94 ieee80211_if_sta_set_mesh_id(&sdata->u.sta, 95 params->mesh_id_len, 96 params->mesh_id); 97 98 /* we're under RTNL so all this is fine */ 99 if (unlikely(local->reg_state == IEEE80211_DEV_UNREGISTERED)) { 100 __ieee80211_if_del(local, sdata); 101 return -ENODEV; 102 } 103 list_add_tail_rcu(&sdata->list, &local->interfaces); 104 105 if (new_dev) 106 *new_dev = ndev; 107 108 return 0; 109 110 fail: 111 free_netdev(ndev); 112 return ret; 113 } 114 115 void ieee80211_if_set_type(struct net_device *dev, int type) 116 { 117 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 118 int oldtype = sdata->vif.type; 119 120 /* 121 * We need to call this function on the master interface 122 * which already has a hard_start_xmit routine assigned 123 * which must not be changed. 124 */ 125 if (dev != sdata->local->mdev) 126 dev->hard_start_xmit = ieee80211_subif_start_xmit; 127 128 /* 129 * Called even when register_netdevice fails, it would 130 * oops if assigned before initialising the rest. 131 */ 132 dev->uninit = ieee80211_if_reinit; 133 134 /* most have no BSS pointer */ 135 sdata->bss = NULL; 136 sdata->vif.type = type; 137 138 sdata->basic_rates = 0; 139 140 switch (type) { 141 case IEEE80211_IF_TYPE_WDS: 142 /* nothing special */ 143 break; 144 case IEEE80211_IF_TYPE_VLAN: 145 sdata->u.vlan.ap = NULL; 146 break; 147 case IEEE80211_IF_TYPE_AP: 148 sdata->u.ap.force_unicast_rateidx = -1; 149 sdata->u.ap.max_ratectrl_rateidx = -1; 150 skb_queue_head_init(&sdata->u.ap.ps_bc_buf); 151 sdata->bss = &sdata->u.ap; 152 INIT_LIST_HEAD(&sdata->u.ap.vlans); 153 break; 154 case IEEE80211_IF_TYPE_MESH_POINT: 155 case IEEE80211_IF_TYPE_STA: 156 case IEEE80211_IF_TYPE_IBSS: { 157 struct ieee80211_sub_if_data *msdata; 158 struct ieee80211_if_sta *ifsta; 159 160 ifsta = &sdata->u.sta; 161 INIT_WORK(&ifsta->work, ieee80211_sta_work); 162 setup_timer(&ifsta->timer, ieee80211_sta_timer, 163 (unsigned long) sdata); 164 skb_queue_head_init(&ifsta->skb_queue); 165 166 ifsta->capab = WLAN_CAPABILITY_ESS; 167 ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN | 168 IEEE80211_AUTH_ALG_SHARED_KEY; 169 ifsta->flags |= IEEE80211_STA_CREATE_IBSS | 170 IEEE80211_STA_WMM_ENABLED | 171 IEEE80211_STA_AUTO_BSSID_SEL | 172 IEEE80211_STA_AUTO_CHANNEL_SEL; 173 174 msdata = IEEE80211_DEV_TO_SUB_IF(sdata->local->mdev); 175 sdata->bss = &msdata->u.ap; 176 177 if (ieee80211_vif_is_mesh(&sdata->vif)) 178 ieee80211_mesh_init_sdata(sdata); 179 break; 180 } 181 case IEEE80211_IF_TYPE_MNTR: 182 dev->type = ARPHRD_IEEE80211_RADIOTAP; 183 dev->hard_start_xmit = ieee80211_monitor_start_xmit; 184 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL | 185 MONITOR_FLAG_OTHER_BSS; 186 break; 187 default: 188 printk(KERN_WARNING "%s: %s: Unknown interface type 0x%x", 189 dev->name, __func__, type); 190 } 191 ieee80211_debugfs_change_if_type(sdata, oldtype); 192 } 193 194 /* Must be called with rtnl lock held. */ 195 void ieee80211_if_reinit(struct net_device *dev) 196 { 197 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 198 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 199 struct sk_buff *skb; 200 int flushed; 201 202 ASSERT_RTNL(); 203 204 ieee80211_free_keys(sdata); 205 206 ieee80211_if_sdata_deinit(sdata); 207 208 /* Need to handle mesh specially to allow eliding the function call */ 209 if (ieee80211_vif_is_mesh(&sdata->vif)) 210 mesh_rmc_free(dev); 211 212 switch (sdata->vif.type) { 213 case IEEE80211_IF_TYPE_INVALID: 214 /* cannot happen */ 215 WARN_ON(1); 216 break; 217 case IEEE80211_IF_TYPE_AP: { 218 /* Remove all virtual interfaces that use this BSS 219 * as their sdata->bss */ 220 struct ieee80211_sub_if_data *tsdata, *n; 221 struct beacon_data *beacon; 222 223 list_for_each_entry_safe(tsdata, n, &local->interfaces, list) { 224 if (tsdata != sdata && tsdata->bss == &sdata->u.ap) { 225 printk(KERN_DEBUG "%s: removing virtual " 226 "interface %s because its BSS interface" 227 " is being removed\n", 228 sdata->dev->name, tsdata->dev->name); 229 list_del_rcu(&tsdata->list); 230 /* 231 * We have lots of time and can afford 232 * to sync for each interface 233 */ 234 synchronize_rcu(); 235 __ieee80211_if_del(local, tsdata); 236 } 237 } 238 239 beacon = sdata->u.ap.beacon; 240 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 241 synchronize_rcu(); 242 kfree(beacon); 243 244 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) { 245 local->total_ps_buffered--; 246 dev_kfree_skb(skb); 247 } 248 249 break; 250 } 251 case IEEE80211_IF_TYPE_WDS: 252 /* nothing to do */ 253 break; 254 case IEEE80211_IF_TYPE_MESH_POINT: 255 case IEEE80211_IF_TYPE_STA: 256 case IEEE80211_IF_TYPE_IBSS: 257 kfree(sdata->u.sta.extra_ie); 258 sdata->u.sta.extra_ie = NULL; 259 kfree(sdata->u.sta.assocreq_ies); 260 sdata->u.sta.assocreq_ies = NULL; 261 kfree(sdata->u.sta.assocresp_ies); 262 sdata->u.sta.assocresp_ies = NULL; 263 if (sdata->u.sta.probe_resp) { 264 dev_kfree_skb(sdata->u.sta.probe_resp); 265 sdata->u.sta.probe_resp = NULL; 266 } 267 268 break; 269 case IEEE80211_IF_TYPE_MNTR: 270 dev->type = ARPHRD_ETHER; 271 break; 272 case IEEE80211_IF_TYPE_VLAN: 273 sdata->u.vlan.ap = NULL; 274 break; 275 } 276 277 flushed = sta_info_flush(local, sdata); 278 WARN_ON(flushed); 279 280 memset(&sdata->u, 0, sizeof(sdata->u)); 281 ieee80211_if_sdata_init(sdata); 282 } 283 284 /* Must be called with rtnl lock held. */ 285 void __ieee80211_if_del(struct ieee80211_local *local, 286 struct ieee80211_sub_if_data *sdata) 287 { 288 struct net_device *dev = sdata->dev; 289 290 ieee80211_debugfs_remove_netdev(sdata); 291 unregister_netdevice(dev); 292 /* Except master interface, the net_device will be freed by 293 * net_device->destructor (i. e. ieee80211_if_free). */ 294 } 295 296 /* Must be called with rtnl lock held. */ 297 int ieee80211_if_remove(struct net_device *dev, const char *name, int id) 298 { 299 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 300 struct ieee80211_sub_if_data *sdata, *n; 301 302 ASSERT_RTNL(); 303 304 list_for_each_entry_safe(sdata, n, &local->interfaces, list) { 305 if ((sdata->vif.type == id || id == -1) && 306 strcmp(name, sdata->dev->name) == 0 && 307 sdata->dev != local->mdev) { 308 list_del_rcu(&sdata->list); 309 synchronize_rcu(); 310 __ieee80211_if_del(local, sdata); 311 return 0; 312 } 313 } 314 return -ENODEV; 315 } 316 317 void ieee80211_if_free(struct net_device *dev) 318 { 319 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 320 321 ieee80211_if_sdata_deinit(sdata); 322 free_netdev(dev); 323 } 324