1 /*******************************************************************************
2 
3   Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
4 
5   Portions of this file are based on the WEP enablement code provided by the
6   Host AP project hostap-drivers v0.1.3
7   Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
8   <j@w1.fi>
9   Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
10 
11   This program is free software; you can redistribute it and/or modify it
12   under the terms of version 2 of the GNU General Public License as
13   published by the Free Software Foundation.
14 
15   This program is distributed in the hope that it will be useful, but WITHOUT
16   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18   more details.
19 
20   You should have received a copy of the GNU General Public License along with
21   this program; if not, write to the Free Software Foundation, Inc., 59
22   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23 
24   The full GNU General Public License is included in this distribution in the
25   file called LICENSE.
26 
27   Contact Information:
28   Intel Linux Wireless <ilw@linux.intel.com>
29   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30 
31 *******************************************************************************/
32 
33 #include <linux/compiler.h>
34 #include <linux/errno.h>
35 #include <linux/if_arp.h>
36 #include <linux/in6.h>
37 #include <linux/in.h>
38 #include <linux/ip.h>
39 #include <linux/kernel.h>
40 #include <linux/module.h>
41 #include <linux/netdevice.h>
42 #include <linux/proc_fs.h>
43 #include <linux/skbuff.h>
44 #include <linux/slab.h>
45 #include <linux/tcp.h>
46 #include <linux/types.h>
47 #include <linux/wireless.h>
48 #include <linux/etherdevice.h>
49 #include <linux/uaccess.h>
50 #include <net/net_namespace.h>
51 #include <net/arp.h>
52 
53 #include "libipw.h"
54 
55 #define DRV_DESCRIPTION "802.11 data/management/control stack"
56 #define DRV_NAME        "libipw"
57 #define DRV_PROCNAME	"ieee80211"
58 #define DRV_VERSION	LIBIPW_VERSION
59 #define DRV_COPYRIGHT   "Copyright (C) 2004-2005 Intel Corporation <jketreno@linux.intel.com>"
60 
61 MODULE_VERSION(DRV_VERSION);
62 MODULE_DESCRIPTION(DRV_DESCRIPTION);
63 MODULE_AUTHOR(DRV_COPYRIGHT);
64 MODULE_LICENSE("GPL");
65 
66 static struct cfg80211_ops libipw_config_ops = { };
67 static void *libipw_wiphy_privid = &libipw_wiphy_privid;
68 
69 static int libipw_networks_allocate(struct libipw_device *ieee)
70 {
71 	int i, j;
72 
73 	for (i = 0; i < MAX_NETWORK_COUNT; i++) {
74 		ieee->networks[i] = kzalloc(sizeof(struct libipw_network),
75 					    GFP_KERNEL);
76 		if (!ieee->networks[i]) {
77 			LIBIPW_ERROR("Out of memory allocating beacons\n");
78 			for (j = 0; j < i; j++)
79 				kfree(ieee->networks[j]);
80 			return -ENOMEM;
81 		}
82 	}
83 
84 	return 0;
85 }
86 
87 static inline void libipw_networks_free(struct libipw_device *ieee)
88 {
89 	int i;
90 
91 	for (i = 0; i < MAX_NETWORK_COUNT; i++)
92 		kfree(ieee->networks[i]);
93 }
94 
95 void libipw_networks_age(struct libipw_device *ieee,
96                             unsigned long age_secs)
97 {
98 	struct libipw_network *network = NULL;
99 	unsigned long flags;
100 	unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
101 
102 	spin_lock_irqsave(&ieee->lock, flags);
103 	list_for_each_entry(network, &ieee->network_list, list) {
104 		network->last_scanned -= age_jiffies;
105 	}
106 	spin_unlock_irqrestore(&ieee->lock, flags);
107 }
108 EXPORT_SYMBOL(libipw_networks_age);
109 
110 static void libipw_networks_initialize(struct libipw_device *ieee)
111 {
112 	int i;
113 
114 	INIT_LIST_HEAD(&ieee->network_free_list);
115 	INIT_LIST_HEAD(&ieee->network_list);
116 	for (i = 0; i < MAX_NETWORK_COUNT; i++)
117 		list_add_tail(&ieee->networks[i]->list,
118 			      &ieee->network_free_list);
119 }
120 
121 struct net_device *alloc_libipw(int sizeof_priv, int monitor)
122 {
123 	struct libipw_device *ieee;
124 	struct net_device *dev;
125 	int err;
126 
127 	LIBIPW_DEBUG_INFO("Initializing...\n");
128 
129 	dev = alloc_etherdev(sizeof(struct libipw_device) + sizeof_priv);
130 	if (!dev)
131 		goto failed;
132 
133 	ieee = netdev_priv(dev);
134 
135 	ieee->dev = dev;
136 
137 	if (!monitor) {
138 		ieee->wdev.wiphy = wiphy_new(&libipw_config_ops, 0);
139 		if (!ieee->wdev.wiphy) {
140 			LIBIPW_ERROR("Unable to allocate wiphy.\n");
141 			goto failed_free_netdev;
142 		}
143 
144 		ieee->dev->ieee80211_ptr = &ieee->wdev;
145 		ieee->wdev.iftype = NL80211_IFTYPE_STATION;
146 
147 		/* Fill-out wiphy structure bits we know...  Not enough info
148 		   here to call set_wiphy_dev or set MAC address or channel info
149 		   -- have to do that in ->ndo_init... */
150 		ieee->wdev.wiphy->privid = libipw_wiphy_privid;
151 
152 		ieee->wdev.wiphy->max_scan_ssids = 1;
153 		ieee->wdev.wiphy->max_scan_ie_len = 0;
154 		ieee->wdev.wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
155 						| BIT(NL80211_IFTYPE_ADHOC);
156 	}
157 
158 	err = libipw_networks_allocate(ieee);
159 	if (err) {
160 		LIBIPW_ERROR("Unable to allocate beacon storage: %d\n", err);
161 		goto failed_free_wiphy;
162 	}
163 	libipw_networks_initialize(ieee);
164 
165 	/* Default fragmentation threshold is maximum payload size */
166 	ieee->fts = DEFAULT_FTS;
167 	ieee->rts = DEFAULT_FTS;
168 	ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
169 	ieee->open_wep = 1;
170 
171 	/* Default to enabling full open WEP with host based encrypt/decrypt */
172 	ieee->host_encrypt = 1;
173 	ieee->host_decrypt = 1;
174 	ieee->host_mc_decrypt = 1;
175 
176 	/* Host fragmentation in Open mode. Default is enabled.
177 	 * Note: host fragmentation is always enabled if host encryption
178 	 * is enabled. For cards can do hardware encryption, they must do
179 	 * hardware fragmentation as well. So we don't need a variable
180 	 * like host_enc_frag. */
181 	ieee->host_open_frag = 1;
182 	ieee->ieee802_1x = 1;	/* Default to supporting 802.1x */
183 
184 	spin_lock_init(&ieee->lock);
185 
186 	lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
187 
188 	ieee->wpa_enabled = 0;
189 	ieee->drop_unencrypted = 0;
190 	ieee->privacy_invoked = 0;
191 
192 	return dev;
193 
194 failed_free_wiphy:
195 	if (!monitor)
196 		wiphy_free(ieee->wdev.wiphy);
197 failed_free_netdev:
198 	free_netdev(dev);
199 failed:
200 	return NULL;
201 }
202 EXPORT_SYMBOL(alloc_libipw);
203 
204 void free_libipw(struct net_device *dev, int monitor)
205 {
206 	struct libipw_device *ieee = netdev_priv(dev);
207 
208 	lib80211_crypt_info_free(&ieee->crypt_info);
209 
210 	libipw_networks_free(ieee);
211 
212 	/* free cfg80211 resources */
213 	if (!monitor)
214 		wiphy_free(ieee->wdev.wiphy);
215 
216 	free_netdev(dev);
217 }
218 EXPORT_SYMBOL(free_libipw);
219 
220 #ifdef CONFIG_LIBIPW_DEBUG
221 
222 static int debug = 0;
223 u32 libipw_debug_level = 0;
224 EXPORT_SYMBOL_GPL(libipw_debug_level);
225 static struct proc_dir_entry *libipw_proc = NULL;
226 
227 static int debug_level_proc_show(struct seq_file *m, void *v)
228 {
229 	seq_printf(m, "0x%08X\n", libipw_debug_level);
230 	return 0;
231 }
232 
233 static int debug_level_proc_open(struct inode *inode, struct file *file)
234 {
235 	return single_open(file, debug_level_proc_show, NULL);
236 }
237 
238 static ssize_t debug_level_proc_write(struct file *file,
239 		const char __user *buffer, size_t count, loff_t *pos)
240 {
241 	char buf[] = "0x00000000\n";
242 	size_t len = min(sizeof(buf) - 1, count);
243 	unsigned long val;
244 
245 	if (copy_from_user(buf, buffer, len))
246 		return count;
247 	buf[len] = 0;
248 	if (sscanf(buf, "%li", &val) != 1)
249 		printk(KERN_INFO DRV_NAME
250 		       ": %s is not in hex or decimal form.\n", buf);
251 	else
252 		libipw_debug_level = val;
253 
254 	return strnlen(buf, len);
255 }
256 
257 static const struct file_operations debug_level_proc_fops = {
258 	.owner		= THIS_MODULE,
259 	.open		= debug_level_proc_open,
260 	.read		= seq_read,
261 	.llseek		= seq_lseek,
262 	.release	= single_release,
263 	.write		= debug_level_proc_write,
264 };
265 #endif				/* CONFIG_LIBIPW_DEBUG */
266 
267 static int __init libipw_init(void)
268 {
269 #ifdef CONFIG_LIBIPW_DEBUG
270 	struct proc_dir_entry *e;
271 
272 	libipw_debug_level = debug;
273 	libipw_proc = proc_mkdir(DRV_PROCNAME, init_net.proc_net);
274 	if (libipw_proc == NULL) {
275 		LIBIPW_ERROR("Unable to create " DRV_PROCNAME
276 				" proc directory\n");
277 		return -EIO;
278 	}
279 	e = proc_create("debug_level", S_IRUGO | S_IWUSR, libipw_proc,
280 			&debug_level_proc_fops);
281 	if (!e) {
282 		remove_proc_entry(DRV_PROCNAME, init_net.proc_net);
283 		libipw_proc = NULL;
284 		return -EIO;
285 	}
286 #endif				/* CONFIG_LIBIPW_DEBUG */
287 
288 	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
289 	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
290 
291 	return 0;
292 }
293 
294 static void __exit libipw_exit(void)
295 {
296 #ifdef CONFIG_LIBIPW_DEBUG
297 	if (libipw_proc) {
298 		remove_proc_entry("debug_level", libipw_proc);
299 		remove_proc_entry(DRV_PROCNAME, init_net.proc_net);
300 		libipw_proc = NULL;
301 	}
302 #endif				/* CONFIG_LIBIPW_DEBUG */
303 }
304 
305 #ifdef CONFIG_LIBIPW_DEBUG
306 #include <linux/moduleparam.h>
307 module_param(debug, int, 0444);
308 MODULE_PARM_DESC(debug, "debug output mask");
309 #endif				/* CONFIG_LIBIPW_DEBUG */
310 
311 module_exit(libipw_exit);
312 module_init(libipw_init);
313