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 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/kernel.h> 12 #include <linux/if_arp.h> 13 #include <linux/netdevice.h> 14 #include <linux/rtnetlink.h> 15 #include <net/mac80211.h> 16 #include "ieee80211_i.h" 17 #include "sta_info.h" 18 #include "debugfs_netdev.h" 19 #include "mesh.h" 20 21 /* 22 * Called when the netdev is removed or, by the code below, before 23 * the interface type changes. 24 */ 25 static void ieee80211_teardown_sdata(struct net_device *dev) 26 { 27 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 28 struct ieee80211_local *local = sdata->local; 29 struct beacon_data *beacon; 30 struct sk_buff *skb; 31 int flushed; 32 int i; 33 34 ieee80211_debugfs_remove_netdev(sdata); 35 36 /* free extra data */ 37 ieee80211_free_keys(sdata); 38 39 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 40 __skb_queue_purge(&sdata->fragments[i].skb_list); 41 sdata->fragment_next = 0; 42 43 switch (sdata->vif.type) { 44 case IEEE80211_IF_TYPE_AP: 45 beacon = sdata->u.ap.beacon; 46 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 47 synchronize_rcu(); 48 kfree(beacon); 49 50 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) { 51 local->total_ps_buffered--; 52 dev_kfree_skb(skb); 53 } 54 55 break; 56 case IEEE80211_IF_TYPE_MESH_POINT: 57 /* Allow compiler to elide mesh_rmc_free call. */ 58 if (ieee80211_vif_is_mesh(&sdata->vif)) 59 mesh_rmc_free(dev); 60 /* fall through */ 61 case IEEE80211_IF_TYPE_STA: 62 case IEEE80211_IF_TYPE_IBSS: 63 kfree(sdata->u.sta.extra_ie); 64 kfree(sdata->u.sta.assocreq_ies); 65 kfree(sdata->u.sta.assocresp_ies); 66 kfree_skb(sdata->u.sta.probe_resp); 67 break; 68 case IEEE80211_IF_TYPE_WDS: 69 case IEEE80211_IF_TYPE_VLAN: 70 case IEEE80211_IF_TYPE_MNTR: 71 break; 72 case IEEE80211_IF_TYPE_INVALID: 73 BUG(); 74 break; 75 } 76 77 flushed = sta_info_flush(local, sdata); 78 WARN_ON(flushed); 79 } 80 81 /* 82 * Helper function to initialise an interface to a specific type. 83 */ 84 static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata, 85 enum ieee80211_if_types type) 86 { 87 struct ieee80211_if_sta *ifsta; 88 89 /* clear type-dependent union */ 90 memset(&sdata->u, 0, sizeof(sdata->u)); 91 92 /* and set some type-dependent values */ 93 sdata->vif.type = type; 94 95 /* only monitor differs */ 96 sdata->dev->type = ARPHRD_ETHER; 97 98 switch (type) { 99 case IEEE80211_IF_TYPE_AP: 100 skb_queue_head_init(&sdata->u.ap.ps_bc_buf); 101 INIT_LIST_HEAD(&sdata->u.ap.vlans); 102 break; 103 case IEEE80211_IF_TYPE_MESH_POINT: 104 case IEEE80211_IF_TYPE_STA: 105 case IEEE80211_IF_TYPE_IBSS: 106 ifsta = &sdata->u.sta; 107 INIT_WORK(&ifsta->work, ieee80211_sta_work); 108 setup_timer(&ifsta->timer, ieee80211_sta_timer, 109 (unsigned long) sdata); 110 skb_queue_head_init(&ifsta->skb_queue); 111 112 ifsta->capab = WLAN_CAPABILITY_ESS; 113 ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN | 114 IEEE80211_AUTH_ALG_SHARED_KEY; 115 ifsta->flags |= IEEE80211_STA_CREATE_IBSS | 116 IEEE80211_STA_AUTO_BSSID_SEL | 117 IEEE80211_STA_AUTO_CHANNEL_SEL; 118 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4) 119 ifsta->flags |= IEEE80211_STA_WMM_ENABLED; 120 121 if (ieee80211_vif_is_mesh(&sdata->vif)) 122 ieee80211_mesh_init_sdata(sdata); 123 break; 124 case IEEE80211_IF_TYPE_MNTR: 125 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP; 126 sdata->dev->hard_start_xmit = ieee80211_monitor_start_xmit; 127 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL | 128 MONITOR_FLAG_OTHER_BSS; 129 break; 130 case IEEE80211_IF_TYPE_WDS: 131 case IEEE80211_IF_TYPE_VLAN: 132 break; 133 case IEEE80211_IF_TYPE_INVALID: 134 BUG(); 135 break; 136 } 137 138 ieee80211_debugfs_add_netdev(sdata); 139 } 140 141 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata, 142 enum ieee80211_if_types type) 143 { 144 ASSERT_RTNL(); 145 146 if (type == sdata->vif.type) 147 return 0; 148 149 /* 150 * We could, here, on changes between IBSS/STA/MESH modes, 151 * invoke an MLME function instead that disassociates etc. 152 * and goes into the requested mode. 153 */ 154 155 if (netif_running(sdata->dev)) 156 return -EBUSY; 157 158 /* Purge and reset type-dependent state. */ 159 ieee80211_teardown_sdata(sdata->dev); 160 ieee80211_setup_sdata(sdata, type); 161 162 /* reset some values that shouldn't be kept across type changes */ 163 sdata->basic_rates = 0; 164 sdata->drop_unencrypted = 0; 165 166 return 0; 167 } 168 169 int ieee80211_if_add(struct ieee80211_local *local, const char *name, 170 struct net_device **new_dev, enum ieee80211_if_types type, 171 struct vif_params *params) 172 { 173 struct net_device *ndev; 174 struct ieee80211_sub_if_data *sdata = NULL; 175 int ret, i; 176 177 ASSERT_RTNL(); 178 179 ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size, 180 name, ieee80211_if_setup); 181 if (!ndev) 182 return -ENOMEM; 183 184 ndev->needed_headroom = local->tx_headroom + 185 4*6 /* four MAC addresses */ 186 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */ 187 + 6 /* mesh */ 188 + 8 /* rfc1042/bridge tunnel */ 189 - ETH_HLEN /* ethernet hard_header_len */ 190 + IEEE80211_ENCRYPT_HEADROOM; 191 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM; 192 193 ret = dev_alloc_name(ndev, ndev->name); 194 if (ret < 0) 195 goto fail; 196 197 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 198 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy)); 199 200 /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */ 201 sdata = netdev_priv(ndev); 202 ndev->ieee80211_ptr = &sdata->wdev; 203 204 /* initialise type-independent data */ 205 sdata->wdev.wiphy = local->hw.wiphy; 206 sdata->local = local; 207 sdata->dev = ndev; 208 209 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 210 skb_queue_head_init(&sdata->fragments[i].skb_list); 211 212 INIT_LIST_HEAD(&sdata->key_list); 213 214 sdata->force_unicast_rateidx = -1; 215 sdata->max_ratectrl_rateidx = -1; 216 217 /* setup type-dependent data */ 218 ieee80211_setup_sdata(sdata, type); 219 220 ret = register_netdevice(ndev); 221 if (ret) 222 goto fail; 223 224 ndev->uninit = ieee80211_teardown_sdata; 225 226 if (ieee80211_vif_is_mesh(&sdata->vif) && 227 params && params->mesh_id_len) 228 ieee80211_if_sta_set_mesh_id(&sdata->u.sta, 229 params->mesh_id_len, 230 params->mesh_id); 231 232 list_add_tail_rcu(&sdata->list, &local->interfaces); 233 234 if (new_dev) 235 *new_dev = ndev; 236 237 return 0; 238 239 fail: 240 free_netdev(ndev); 241 return ret; 242 } 243 244 void ieee80211_if_remove(struct net_device *dev) 245 { 246 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 247 248 ASSERT_RTNL(); 249 250 list_del_rcu(&sdata->list); 251 synchronize_rcu(); 252 unregister_netdevice(dev); 253 } 254 255 /* 256 * Remove all interfaces, may only be called at hardware unregistration 257 * time because it doesn't do RCU-safe list removals. 258 */ 259 void ieee80211_remove_interfaces(struct ieee80211_local *local) 260 { 261 struct ieee80211_sub_if_data *sdata, *tmp; 262 263 ASSERT_RTNL(); 264 265 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) { 266 list_del(&sdata->list); 267 unregister_netdevice(sdata->dev); 268 } 269 } 270