err.no Git - linux-2.6/blob - 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         ieee->crypt_quiesced = 0;
 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 void free_ieee80211(struct net_device *dev)
 160 {
 161         struct ieee80211_device *ieee = netdev_priv(dev);
 162
 163         int i;
 164
 165         ieee80211_crypt_quiescing(ieee);
 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 __user * buffer,
 198                              unsigned long count, void *data)
 199 {
 200         char buf[] = "0x00000000\n";
 201         unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
 202         unsigned long val;
 203
 204         if (copy_from_user(buf, buffer, len))
 205                 return count;
 206         buf[len] = 0;
 207         if (sscanf(buf, "%li", &val) != 1)
 208                 printk(KERN_INFO DRV_NAME
 209                        ": %s is not in hex or decimal form.\n", buf);
 210         else
 211                 ieee80211_debug_level = val;
 212
 213         return strnlen(buf, len);
 214 }
 215
 216 static int __init ieee80211_init(void)
 217 {
 218         struct proc_dir_entry *e;
 219
 220         ieee80211_debug_level = debug;
 221         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
 222         if (ieee80211_proc == NULL) {
 223                 IEEE80211_ERROR("Unable to create " DRV_NAME
 224                                 " proc directory\n");
 225                 return -EIO;
 226         }
 227         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 228                               ieee80211_proc);
 229         if (!e) {
 230                 remove_proc_entry(DRV_NAME, proc_net);
 231                 ieee80211_proc = NULL;
 232                 return -EIO;
 233         }
 234         e->read_proc = show_debug_level;
 235         e->write_proc = store_debug_level;
 236         e->data = NULL;
 237
 238         return 0;
 239 }
 240
 241 static void __exit ieee80211_exit(void)
 242 {
 243         if (ieee80211_proc) {
 244                 remove_proc_entry("debug_level", ieee80211_proc);
 245                 remove_proc_entry(DRV_NAME, proc_net);
 246                 ieee80211_proc = NULL;
 247         }
 248 }
 249
 250 #include <linux/moduleparam.h>
 251 module_param(debug, int, 0444);
 252 MODULE_PARM_DESC(debug, "debug output mask");
 253
 254 module_exit(ieee80211_exit);
 255 module_init(ieee80211_init);
 256 #endif
 257
 258 const char *escape_essid(const char *essid, u8 essid_len)
 259 {
 260         static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
 261         const char *s = essid;
 262         char *d = escaped;
 263
 264         if (ieee80211_is_empty_essid(essid, essid_len)) {
 265                 memcpy(escaped, "<hidden>", sizeof("<hidden>"));
 266                 return escaped;
 267         }
 268
 269         essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
 270         while (essid_len--) {
 271                 if (*s == '\0') {
 272                         *d++ = '\\';
 273                         *d++ = '0';
 274                         s++;
 275                 } else {
 276                         *d++ = *s++;
 277                 }
 278         }
 279         *d = '\0';
 280         return escaped;
 281 }
 282
 283 EXPORT_SYMBOL(alloc_ieee80211);
 284 EXPORT_SYMBOL(free_ieee80211);
 285 EXPORT_SYMBOL(escape_essid);