iface.c 7.19 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/kernel.h>
#include <linux/if_arp.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
#include <net/mac80211.h>
#include "ieee80211_i.h"
#include "sta_info.h"
17
#include "debugfs_netdev.h"
18
#include "mesh.h"
19 20 21 22 23 24 25 26 27

void ieee80211_if_sdata_init(struct ieee80211_sub_if_data *sdata)
{
	int i;

	/* Default values for sub-interface parameters */
	sdata->drop_unencrypted = 0;
	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
		skb_queue_head_init(&sdata->fragments[i].skb_list);
28 29

	INIT_LIST_HEAD(&sdata->key_list);
30 31 32

	sdata->force_unicast_rateidx = -1;
	sdata->max_ratectrl_rateidx = -1;
33 34 35 36 37 38
}

static void ieee80211_if_sdata_deinit(struct ieee80211_sub_if_data *sdata)
{
	int i;

Johannes Berg's avatar
Johannes Berg committed
39
	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
40 41 42 43
		__skb_queue_purge(&sdata->fragments[i].skb_list);
}

/* Must be called with rtnl lock held. */
44
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
45 46
		     struct net_device **new_dev, int type,
		     struct vif_params *params)
47 48 49 50 51 52
{
	struct net_device *ndev;
	struct ieee80211_sub_if_data *sdata = NULL;
	int ret;

	ASSERT_RTNL();
53
	ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size,
54 55 56 57
			    name, ieee80211_if_setup);
	if (!ndev)
		return -ENOMEM;

58 59 60 61 62 63 64 65 66
	ndev->needed_headroom = local->tx_headroom +
				4*6 /* four MAC addresses */
				+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
				+ 6 /* mesh */
				+ 8 /* rfc1042/bridge tunnel */
				- ETH_HLEN /* ethernet hard_header_len */
				+ IEEE80211_ENCRYPT_HEADROOM;
	ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;

67 68 69 70 71 72 73
	ret = dev_alloc_name(ndev, ndev->name);
	if (ret < 0)
		goto fail;

	memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
	SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));

74 75
	/* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
	sdata = netdev_priv(ndev);
76 77
	ndev->ieee80211_ptr = &sdata->wdev;
	sdata->wdev.wiphy = local->hw.wiphy;
78
	sdata->vif.type = IEEE80211_IF_TYPE_AP;
79 80 81 82 83 84 85 86
	sdata->dev = ndev;
	sdata->local = local;
	ieee80211_if_sdata_init(sdata);

	ret = register_netdevice(ndev);
	if (ret)
		goto fail;

87
	ieee80211_debugfs_add_netdev(sdata);
88 89
	ieee80211_if_set_type(ndev, type);

Johannes Berg's avatar
Johannes Berg committed
90 91 92 93 94
	if (ieee80211_vif_is_mesh(&sdata->vif) &&
	    params && params->mesh_id_len)
		ieee80211_if_sta_set_mesh_id(&sdata->u.sta,
					     params->mesh_id_len,
					     params->mesh_id);
95

96
	/* we're under RTNL so all this is fine */
97 98 99 100
	if (unlikely(local->reg_state == IEEE80211_DEV_UNREGISTERED)) {
		__ieee80211_if_del(local, sdata);
		return -ENODEV;
	}
101 102
	list_add_tail_rcu(&sdata->list, &local->interfaces);

103 104 105 106 107 108 109 110 111 112 113 114 115
	if (new_dev)
		*new_dev = ndev;

	return 0;

fail:
	free_netdev(ndev);
	return ret;
}

void ieee80211_if_set_type(struct net_device *dev, int type)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
116
	int oldtype = sdata->vif.type;
117

118 119 120 121 122 123 124 125
	/*
	 * Called even when register_netdevice fails, it would
	 * oops if assigned before initialising the rest.
	 */
	dev->uninit = ieee80211_if_reinit;

	/* most have no BSS pointer */
	sdata->bss = NULL;
126
	sdata->vif.type = type;
127

128 129
	sdata->basic_rates = 0;

130 131 132
	switch (type) {
	case IEEE80211_IF_TYPE_WDS:
	case IEEE80211_IF_TYPE_VLAN:
133
		/* nothing special */
134 135 136
		break;
	case IEEE80211_IF_TYPE_AP:
		skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
137
		INIT_LIST_HEAD(&sdata->u.ap.vlans);
138
		break;
139
	case IEEE80211_IF_TYPE_MESH_POINT:
140 141 142 143 144 145 146 147 148 149 150 151 152
	case IEEE80211_IF_TYPE_STA:
	case IEEE80211_IF_TYPE_IBSS: {
		struct ieee80211_if_sta *ifsta;

		ifsta = &sdata->u.sta;
		INIT_WORK(&ifsta->work, ieee80211_sta_work);
		setup_timer(&ifsta->timer, ieee80211_sta_timer,
			    (unsigned long) sdata);
		skb_queue_head_init(&ifsta->skb_queue);

		ifsta->capab = WLAN_CAPABILITY_ESS;
		ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN |
			IEEE80211_AUTH_ALG_SHARED_KEY;
153 154 155
		ifsta->flags |= IEEE80211_STA_CREATE_IBSS |
			IEEE80211_STA_AUTO_BSSID_SEL |
			IEEE80211_STA_AUTO_CHANNEL_SEL;
156
		if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4)
157
			ifsta->flags |= IEEE80211_STA_WMM_ENABLED;
158

Johannes Berg's avatar
Johannes Berg committed
159 160
		if (ieee80211_vif_is_mesh(&sdata->vif))
			ieee80211_mesh_init_sdata(sdata);
161 162 163 164
		break;
	}
	case IEEE80211_IF_TYPE_MNTR:
		dev->type = ARPHRD_IEEE80211_RADIOTAP;
165
		dev->hard_start_xmit = ieee80211_monitor_start_xmit;
166 167
		sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
				      MONITOR_FLAG_OTHER_BSS;
168
		break;
169 170 171
	case IEEE80211_IF_TYPE_INVALID:
		BUG();
		break;
172
	}
173
	ieee80211_debugfs_change_if_type(sdata, oldtype);
174 175 176 177 178 179 180
}

/* Must be called with rtnl lock held. */
void ieee80211_if_reinit(struct net_device *dev)
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
181
	struct sk_buff *skb;
182
	int flushed;
183 184

	ASSERT_RTNL();
185 186 187

	ieee80211_free_keys(sdata);

188 189
	ieee80211_if_sdata_deinit(sdata);

Johannes Berg's avatar
Johannes Berg committed
190 191 192 193
	/* Need to handle mesh specially to allow eliding the function call */
	if (ieee80211_vif_is_mesh(&sdata->vif))
		mesh_rmc_free(dev);

194
	switch (sdata->vif.type) {
195 196 197 198
	case IEEE80211_IF_TYPE_INVALID:
		/* cannot happen */
		WARN_ON(1);
		break;
199
	case IEEE80211_IF_TYPE_AP: {
200
		struct beacon_data *beacon;
201

202 203 204 205
		beacon = sdata->u.ap.beacon;
		rcu_assign_pointer(sdata->u.ap.beacon, NULL);
		synchronize_rcu();
		kfree(beacon);
206

207 208 209
		while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {
			local->total_ps_buffered--;
			dev_kfree_skb(skb);
210 211 212 213 214
		}

		break;
	}
	case IEEE80211_IF_TYPE_WDS:
215
	case IEEE80211_IF_TYPE_VLAN:
216
		/* nothing to do */
217
		break;
218
	case IEEE80211_IF_TYPE_MESH_POINT:
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
	case IEEE80211_IF_TYPE_STA:
	case IEEE80211_IF_TYPE_IBSS:
		kfree(sdata->u.sta.extra_ie);
		sdata->u.sta.extra_ie = NULL;
		kfree(sdata->u.sta.assocreq_ies);
		sdata->u.sta.assocreq_ies = NULL;
		kfree(sdata->u.sta.assocresp_ies);
		sdata->u.sta.assocresp_ies = NULL;
		if (sdata->u.sta.probe_resp) {
			dev_kfree_skb(sdata->u.sta.probe_resp);
			sdata->u.sta.probe_resp = NULL;
		}

		break;
	case IEEE80211_IF_TYPE_MNTR:
		dev->type = ARPHRD_ETHER;
		break;
	}

238 239
	flushed = sta_info_flush(local, sdata);
	WARN_ON(flushed);
240 241 242 243 244 245 246 247 248 249 250

	memset(&sdata->u, 0, sizeof(sdata->u));
	ieee80211_if_sdata_init(sdata);
}

/* Must be called with rtnl lock held. */
void __ieee80211_if_del(struct ieee80211_local *local,
			struct ieee80211_sub_if_data *sdata)
{
	struct net_device *dev = sdata->dev;

251
	ieee80211_debugfs_remove_netdev(sdata);
252
	unregister_netdevice(dev);
253 254 255 256
	/*
	 * The net_device will be freed by its destructor,
	 * i.e. ieee80211_if_free.
	 */
257 258 259 260 261 262 263 264 265 266
}

/* Must be called with rtnl lock held. */
int ieee80211_if_remove(struct net_device *dev, const char *name, int id)
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct ieee80211_sub_if_data *sdata, *n;

	ASSERT_RTNL();

267
	list_for_each_entry_safe(sdata, n, &local->interfaces, list) {
268
		if ((sdata->vif.type == id || id == -1) &&
269
		    strcmp(name, sdata->dev->name) == 0) {
270 271
			list_del_rcu(&sdata->list);
			synchronize_rcu();
272 273 274 275 276 277 278 279 280 281 282 283 284 285
			__ieee80211_if_del(local, sdata);
			return 0;
		}
	}
	return -ENODEV;
}

void ieee80211_if_free(struct net_device *dev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	ieee80211_if_sdata_deinit(sdata);
	free_netdev(dev);
}