Merge from Linus' tree
[linux-2.6] / 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/proc_fs.h>
44 #include <linux/skbuff.h>
45 #include <linux/slab.h>
46 #include <linux/tcp.h>
47 #include <linux/types.h>
48 #include <linux/version.h>
49 #include <linux/wireless.h>
50 #include <linux/etherdevice.h>
51 #include <asm/uaccess.h>
52 #include <net/arp.h>
53
54 #include <net/ieee80211.h>
55
56 MODULE_DESCRIPTION("802.11 data/management/control stack");
57 MODULE_AUTHOR
58     ("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 =
69             kmalloc(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,
99                               &ieee->network_free_list);
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", err);
123                 goto failed;
124         }
125         ieee80211_networks_initialize(ieee);
126
127         /* Default fragmentation threshold is maximum payload size */
128         ieee->fts = DEFAULT_FTS;
129         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
130         ieee->open_wep = 1;
131
132         /* Default to enabling full open WEP with host based encrypt/decrypt */
133         ieee->host_encrypt = 1;
134         ieee->host_decrypt = 1;
135         ieee->ieee802_1x = 1;   /* Default to supporting 802.1x */
136
137         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
138         init_timer(&ieee->crypt_deinit_timer);
139         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
140         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
141
142         spin_lock_init(&ieee->lock);
143
144         ieee->wpa_enabled = 0;
145         ieee->tkip_countermeasures = 0;
146         ieee->drop_unencrypted = 0;
147         ieee->privacy_invoked = 0;
148         ieee->ieee802_1x = 1;
149
150         return dev;
151
152       failed:
153         if (dev)
154                 free_netdev(dev);
155         return NULL;
156 }
157
158 void free_ieee80211(struct net_device *dev)
159 {
160         struct ieee80211_device *ieee = netdev_priv(dev);
161
162         int i;
163
164         del_timer_sync(&ieee->crypt_deinit_timer);
165         ieee80211_crypt_deinit_entries(ieee, 1);
166
167         for (i = 0; i < WEP_KEYS; i++) {
168                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
169                 if (crypt) {
170                         if (crypt->ops) {
171                                 crypt->ops->deinit(crypt->priv);
172                                 module_put(crypt->ops->owner);
173                         }
174                         kfree(crypt);
175                         ieee->crypt[i] = NULL;
176                 }
177         }
178
179         ieee80211_networks_free(ieee);
180         free_netdev(dev);
181 }
182
183 #ifdef CONFIG_IEEE80211_DEBUG
184
185 static int debug = 0;
186 u32 ieee80211_debug_level = 0;
187 struct proc_dir_entry *ieee80211_proc = NULL;
188
189 static int show_debug_level(char *page, char **start, off_t offset,
190                             int count, int *eof, void *data)
191 {
192         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
193 }
194
195 static int store_debug_level(struct file *file, const char __user * buffer,
196                              unsigned long count, void *data)
197 {
198         char buf[] = "0x00000000";
199         char *p = (char *)buf;
200         unsigned long val;
201
202         if (count > sizeof(buf) - 1)
203                 count = sizeof(buf) - 1;
204
205         if (copy_from_user(buf, buffer, count))
206                 return count;
207         buf[count] = 0;
208         /*
209          * what a FPOS...  What, sscanf(buf, "%i", &val) would be too
210          * scary?
211          */
212         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
213                 p++;
214                 if (p[0] == 'x' || p[0] == 'X')
215                         p++;
216                 val = simple_strtoul(p, &p, 16);
217         } else
218                 val = simple_strtoul(p, &p, 10);
219         if (p == buf)
220                 printk(KERN_INFO DRV_NAME
221                        ": %s is not in hex or decimal form.\n", buf);
222         else
223                 ieee80211_debug_level = val;
224
225         return strlen(buf);
226 }
227
228 static int __init ieee80211_init(void)
229 {
230         struct proc_dir_entry *e;
231
232         ieee80211_debug_level = debug;
233         ieee80211_proc = proc_mkdir(DRV_NAME, proc_net);
234         if (ieee80211_proc == NULL) {
235                 IEEE80211_ERROR("Unable to create " DRV_NAME
236                                 " proc directory\n");
237                 return -EIO;
238         }
239         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
240                               ieee80211_proc);
241         if (!e) {
242                 remove_proc_entry(DRV_NAME, proc_net);
243                 ieee80211_proc = NULL;
244                 return -EIO;
245         }
246         e->read_proc = show_debug_level;
247         e->write_proc = store_debug_level;
248         e->data = NULL;
249
250         return 0;
251 }
252
253 static void __exit ieee80211_exit(void)
254 {
255         if (ieee80211_proc) {
256                 remove_proc_entry("debug_level", ieee80211_proc);
257                 remove_proc_entry(DRV_NAME, proc_net);
258                 ieee80211_proc = NULL;
259         }
260 }
261
262 #include <linux/moduleparam.h>
263 module_param(debug, int, 0444);
264 MODULE_PARM_DESC(debug, "debug output mask");
265
266 module_exit(ieee80211_exit);
267 module_init(ieee80211_init);
268 #endif
269
270 const char *escape_essid(const char *essid, u8 essid_len)
271 {
272         static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
273         const char *s = essid;
274         char *d = escaped;
275
276         if (ieee80211_is_empty_essid(essid, essid_len)) {
277                 memcpy(escaped, "<hidden>", sizeof("<hidden>"));
278                 return escaped;
279         }
280
281         essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
282         while (essid_len--) {
283                 if (*s == '\0') {
284                         *d++ = '\\';
285                         *d++ = '0';
286                         s++;
287                 } else {
288                         *d++ = *s++;
289                 }
290         }
291         *d = '\0';
292         return escaped;
293 }
294
295 EXPORT_SYMBOL(alloc_ieee80211);
296 EXPORT_SYMBOL(free_ieee80211);
297 EXPORT_SYMBOL(escape_essid);