1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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 <asm/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 "ieee80211"
57#define DRV_VERSION LIBIPW_VERSION
58#define DRV_COPYRIGHT "Copyright (C) 2004-2005 Intel Corporation <jketreno@linux.intel.com>"
59
60MODULE_VERSION(DRV_VERSION);
61MODULE_DESCRIPTION(DRV_DESCRIPTION);
62MODULE_AUTHOR(DRV_COPYRIGHT);
63MODULE_LICENSE("GPL");
64
65static int libipw_networks_allocate(struct libipw_device *ieee)
66{
67 if (ieee->networks)
68 return 0;
69
70 ieee->networks =
71 kzalloc(MAX_NETWORK_COUNT * sizeof(struct libipw_network),
72 GFP_KERNEL);
73 if (!ieee->networks) {
74 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
75 ieee->dev->name);
76 return -ENOMEM;
77 }
78
79 return 0;
80}
81
82void libipw_network_reset(struct libipw_network *network)
83{
84 if (!network)
85 return;
86
87 if (network->ibss_dfs) {
88 kfree(network->ibss_dfs);
89 network->ibss_dfs = NULL;
90 }
91}
92
93static inline void libipw_networks_free(struct libipw_device *ieee)
94{
95 int i;
96
97 if (!ieee->networks)
98 return;
99
100 for (i = 0; i < MAX_NETWORK_COUNT; i++)
101 if (ieee->networks[i].ibss_dfs)
102 kfree(ieee->networks[i].ibss_dfs);
103
104 kfree(ieee->networks);
105 ieee->networks = NULL;
106}
107
108void libipw_networks_age(struct libipw_device *ieee,
109 unsigned long age_secs)
110{
111 struct libipw_network *network = NULL;
112 unsigned long flags;
113 unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
114
115 spin_lock_irqsave(&ieee->lock, flags);
116 list_for_each_entry(network, &ieee->network_list, list) {
117 network->last_scanned -= age_jiffies;
118 }
119 spin_unlock_irqrestore(&ieee->lock, flags);
120}
121EXPORT_SYMBOL(libipw_networks_age);
122
123static void libipw_networks_initialize(struct libipw_device *ieee)
124{
125 int i;
126
127 INIT_LIST_HEAD(&ieee->network_free_list);
128 INIT_LIST_HEAD(&ieee->network_list);
129 for (i = 0; i < MAX_NETWORK_COUNT; i++)
130 list_add_tail(&ieee->networks[i].list,
131 &ieee->network_free_list);
132}
133
134int libipw_change_mtu(struct net_device *dev, int new_mtu)
135{
136 if ((new_mtu < 68) || (new_mtu > LIBIPW_DATA_LEN))
137 return -EINVAL;
138 dev->mtu = new_mtu;
139 return 0;
140}
141EXPORT_SYMBOL(libipw_change_mtu);
142
143struct net_device *alloc_ieee80211(int sizeof_priv)
144{
145 struct libipw_device *ieee;
146 struct net_device *dev;
147 int err;
148
149 LIBIPW_DEBUG_INFO("Initializing...\n");
150
151 dev = alloc_etherdev(sizeof(struct libipw_device) + sizeof_priv);
152 if (!dev) {
153 LIBIPW_ERROR("Unable to allocate network device.\n");
154 goto failed;
155 }
156 ieee = netdev_priv(dev);
157
158 ieee->dev = dev;
159
160 err = libipw_networks_allocate(ieee);
161 if (err) {
162 LIBIPW_ERROR("Unable to allocate beacon storage: %d\n", err);
163 goto failed_free_netdev;
164 }
165 libipw_networks_initialize(ieee);
166
167
168 ieee->fts = DEFAULT_FTS;
169 ieee->rts = DEFAULT_FTS;
170 ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
171 ieee->open_wep = 1;
172
173
174 ieee->host_encrypt = 1;
175 ieee->host_decrypt = 1;
176 ieee->host_mc_decrypt = 1;
177
178
179
180
181
182
183 ieee->host_open_frag = 1;
184 ieee->ieee802_1x = 1;
185
186 spin_lock_init(&ieee->lock);
187
188 lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
189
190 ieee->wpa_enabled = 0;
191 ieee->drop_unencrypted = 0;
192 ieee->privacy_invoked = 0;
193
194 return dev;
195
196failed_free_netdev:
197 free_netdev(dev);
198failed:
199 return NULL;
200}
201
202void free_ieee80211(struct net_device *dev)
203{
204 struct libipw_device *ieee = netdev_priv(dev);
205
206 lib80211_crypt_info_free(&ieee->crypt_info);
207
208 libipw_networks_free(ieee);
209 free_netdev(dev);
210}
211
212#ifdef CONFIG_LIBIPW_DEBUG
213
214static int debug = 0;
215u32 libipw_debug_level = 0;
216EXPORT_SYMBOL_GPL(libipw_debug_level);
217static struct proc_dir_entry *libipw_proc = NULL;
218
219static int show_debug_level(char *page, char **start, off_t offset,
220 int count, int *eof, void *data)
221{
222 return snprintf(page, count, "0x%08X\n", libipw_debug_level);
223}
224
225static int store_debug_level(struct file *file, const char __user * buffer,
226 unsigned long count, void *data)
227{
228 char buf[] = "0x00000000\n";
229 unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
230 unsigned long val;
231
232 if (copy_from_user(buf, buffer, len))
233 return count;
234 buf[len] = 0;
235 if (sscanf(buf, "%li", &val) != 1)
236 printk(KERN_INFO DRV_NAME
237 ": %s is not in hex or decimal form.\n", buf);
238 else
239 libipw_debug_level = val;
240
241 return strnlen(buf, len);
242}
243#endif
244
245static int __init libipw_init(void)
246{
247#ifdef CONFIG_LIBIPW_DEBUG
248 struct proc_dir_entry *e;
249
250 libipw_debug_level = debug;
251 libipw_proc = proc_mkdir(DRV_NAME, init_net.proc_net);
252 if (libipw_proc == NULL) {
253 LIBIPW_ERROR("Unable to create " DRV_NAME
254 " proc directory\n");
255 return -EIO;
256 }
257 e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
258 libipw_proc);
259 if (!e) {
260 remove_proc_entry(DRV_NAME, init_net.proc_net);
261 libipw_proc = NULL;
262 return -EIO;
263 }
264 e->read_proc = show_debug_level;
265 e->write_proc = store_debug_level;
266 e->data = NULL;
267#endif
268
269 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
270 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
271
272 return 0;
273}
274
275static void __exit libipw_exit(void)
276{
277#ifdef CONFIG_LIBIPW_DEBUG
278 if (libipw_proc) {
279 remove_proc_entry("debug_level", libipw_proc);
280 remove_proc_entry(DRV_NAME, init_net.proc_net);
281 libipw_proc = NULL;
282 }
283#endif
284}
285
286#ifdef CONFIG_LIBIPW_DEBUG
287#include <linux/moduleparam.h>
288module_param(debug, int, 0444);
289MODULE_PARM_DESC(debug, "debug output mask");
290#endif
291
292module_exit(libipw_exit);
293module_init(libipw_init);
294
295EXPORT_SYMBOL(alloc_ieee80211);
296EXPORT_SYMBOL(free_ieee80211);
297
