[NET] ieee80211 subsystem
[linux-2.6.git] / net / ieee80211 / ieee80211_module.c
1 /*******************************************************************************
2
3   Copyright(c) 2004 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   <jkmaline@cc.hut.fi>
9   Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.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   James P. Ketrenos <ipw2100-admin@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/config.h>
35 #include <linux/errno.h>
36 #include <linux/if_arp.h>
37 #include <linux/in6.h>
38 #include <linux/in.h>
39 #include <linux/ip.h>
40 #include <linux/kernel.h>
41 #include <linux/module.h>
42 #include <linux/netdevice.h>
43 #include <linux/pci.h>
44 #include <linux/proc_fs.h>
45 #include <linux/skbuff.h>
46 #include <linux/slab.h>
47 #include <linux/tcp.h>
48 #include <linux/types.h>
49 #include <linux/version.h>
50 #include <linux/wireless.h>
51 #include <linux/etherdevice.h>
52 #include <asm/uaccess.h>
53 #include <net/arp.h>
54
55 #include <net/ieee80211.h>
56
57 MODULE_DESCRIPTION("802.11 data/management/control stack");
58 MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
59 MODULE_LICENSE("GPL");
60
61 #define DRV_NAME "ieee80211"
62
63 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
64 {
65         if (ieee->networks)
66                 return 0;
67
68         ieee->networks = kmalloc(
69                 MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
70                 GFP_KERNEL);
71         if (!ieee->networks) {
72                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
73                        ieee->dev->name);
74                 return -ENOMEM;
75         }
76
77         memset(ieee->networks, 0,
78                MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));
79
80         return 0;
81 }
82
83 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
84 {
85         if (!ieee->networks)
86                 return;
87         kfree(ieee->networks);
88         ieee->networks = NULL;
89 }
90
91 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
92 {
93         int i;
94
95         INIT_LIST_HEAD(&ieee->network_free_list);
96         INIT_LIST_HEAD(&ieee->network_list);
97         for (i = 0; i < MAX_NETWORK_COUNT; i++)
98                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
99 }
100
101
102 struct net_device *alloc_ieee80211(int sizeof_priv)
103 {
104         struct ieee80211_device *ieee;
105         struct net_device *dev;
106         int err;
107
108         IEEE80211_DEBUG_INFO("Initializing...\n");
109
110         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
111         if (!dev) {
112                 IEEE80211_ERROR("Unable to network device.\n");
113                 goto failed;
114         }
115         ieee = netdev_priv(dev);
116         dev->hard_start_xmit = ieee80211_xmit;
117
118         ieee->dev = dev;
119
120         err = ieee80211_networks_allocate(ieee);
121         if (err) {
122                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
123                                 err);
124                 goto failed;
125         }
126         ieee80211_networks_initialize(ieee);
127
128         /* Default fragmentation threshold is maximum payload size */
129         ieee->fts = DEFAULT_FTS;
130         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
131         ieee->open_wep = 1;
132
133         /* Default to enabling full open WEP with host based encrypt/decrypt */
134         ieee->host_encrypt = 1;
135         ieee->host_decrypt = 1;
136         ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
137
138         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
139         init_timer(&ieee->crypt_deinit_timer);
140         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
141         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
142
143         spin_lock_init(&ieee->lock);
144
145         ieee->wpa_enabled = 0;
146         ieee->tkip_countermeasures = 0;
147         ieee->drop_unencrypted = 0;
148         ieee->privacy_invoked = 0;
149         ieee->ieee802_1x = 1;
150
151         return dev;
152
153  failed:
154         if (dev)
155                 free_netdev(dev);
156         return NULL;
157 }
158
159
160 void free_ieee80211(struct net_device *dev)
161 {
162         struct ieee80211_device *ieee = netdev_priv(dev);
163
164         int i;
165
166         del_timer_sync(&ieee->crypt_deinit_timer);
167         ieee80211_crypt_deinit_entries(ieee, 1);
168
169         for (i = 0; i < WEP_KEYS; i++) {
170                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
171                 if (crypt) {
172                         if (crypt->ops) {
173                                 crypt->ops->deinit(crypt->priv);
174                                 module_put(crypt->ops->owner);
175                         }
176                         kfree(crypt);
177                         ieee->crypt[i] = NULL;
178                 }
179         }
180
181         ieee80211_networks_free(ieee);
182         free_netdev(dev);
183 }
184
185 #ifdef CONFIG_IEEE80211_DEBUG
186
187 static int debug = 0;
188 u32 ieee80211_debug_level = 0;
189 struct proc_dir_entry *ieee80211_proc = NULL;
190
191 static int show_debug_level(char *page, char **start, off_t offset,
192                             int count, int *eof, void *data)
193 {
194         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
195 }
196
197 static int store_debug_level(struct file *file, const char *buffer,
198                              unsigned long count, void *data)
199 {
200         char buf[] = "0x00000000";
201         unsigned long len = min(sizeof(buf) - 1, (u32)count);
202         char *p = (char *)buf;
203         unsigned long val;
204
205         if (copy_from_user(buf, buffer, len))
206                 return count;
207         buf[len] = 0;
208         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
209                 p++;
210                 if (p[0] == 'x' || p[0] == 'X')
211                         p++;
212                 val = simple_strtoul(p, &p, 16);
213         } else
214                 val = simple_strtoul(p, &p, 10);
215         if (p == buf)
216                 printk(KERN_INFO DRV_NAME
217                        ": %s is not in hex or decimal form.\n", buf);
218         else
219                 ieee80211_debug_level = val;
220
221         return strnlen(buf, count);
222 }
223
224 static int __init ieee80211_init(void)
225 {
226         struct proc_dir_entry *e;
227
228         ieee80211_debug_level = debug;
229         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
230         if (ieee80211_proc == NULL) {
231                 IEEE80211_ERROR("Unable to create " DRV_NAME
232                                 " proc directory\n");
233                 return -EIO;
234         }
235         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
236                               ieee80211_proc);
237         if (!e) {
238                 remove_proc_entry(DRV_NAME, proc_net);
239                 ieee80211_proc = NULL;
240                 return -EIO;
241         }
242         e->read_proc = show_debug_level;
243         e->write_proc = store_debug_level;
244         e->data = NULL;
245
246         return 0;
247 }
248
249 static void __exit ieee80211_exit(void)
250 {
251         if (ieee80211_proc) {
252                 remove_proc_entry("debug_level", ieee80211_proc);
253                 remove_proc_entry(DRV_NAME, proc_net);
254                 ieee80211_proc = NULL;
255         }
256 }
257
258 #include <linux/moduleparam.h>
259 module_param(debug, int, 0444);
260 MODULE_PARM_DESC(debug, "debug output mask");
261
262
263 module_exit(ieee80211_exit);
264 module_init(ieee80211_init);
265 #endif
266
267 EXPORT_SYMBOL(alloc_ieee80211);
268 EXPORT_SYMBOL(free_ieee80211);