net/ieee80211/ieee80211_module.c

   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   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/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 <net/ieee80211.h>
  54
  55 #define DRV_DESCRIPTION "802.11 data/management/control stack"
  56 #define DRV_NAME        "ieee80211"
  57 #define DRV_VERSION     IEEE80211_VERSION
  58 #define DRV_COPYRIGHT   "Copyright (C) 2004-2005 Intel Corporation <jketreno@linux.intel.com>"
  59
  60 MODULE_VERSION(DRV_VERSION);
  61 MODULE_DESCRIPTION(DRV_DESCRIPTION);
  62 MODULE_AUTHOR(DRV_COPYRIGHT);
  63 MODULE_LICENSE("GPL");
  64
  65 static int ieee80211_networks_allocate(struct ieee80211_device *ieee)
  66 {
  67         if (ieee->networks)
  68                 return 0;
  69
  70         ieee->networks =
  71             kzalloc(MAX_NETWORK_COUNT * sizeof(struct ieee80211_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
  82 void ieee80211_network_reset(struct ieee80211_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
  93 static inline void ieee80211_networks_free(struct ieee80211_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
 108 static void ieee80211_networks_initialize(struct ieee80211_device *ieee)
 109 {
 110         int i;
 111
 112         INIT_LIST_HEAD(&ieee->network_free_list);
 113         INIT_LIST_HEAD(&ieee->network_list);
 114         for (i = 0; i < MAX_NETWORK_COUNT; i++)
 115                 list_add_tail(&ieee->networks[i].list,
 116                               &ieee->network_free_list);
 117 }
 118
 119 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
 120 {
 121         if ((new_mtu < 68) || (new_mtu > IEEE80211_DATA_LEN))
 122                 return -EINVAL;
 123         dev->mtu = new_mtu;
 124         return 0;
 125 }
 126
 127 static struct net_device_stats *ieee80211_generic_get_stats(
 128         struct net_device *dev)
 129 {
 130         struct ieee80211_device *ieee = netdev_priv(dev);
 131         return &ieee->stats;
 132 }
 133
 134 struct net_device *alloc_ieee80211(int sizeof_priv)
 135 {
 136         struct ieee80211_device *ieee;
 137         struct net_device *dev;
 138         int err;
 139
 140         IEEE80211_DEBUG_INFO("Initializing...\n");
 141
 142         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 143         if (!dev) {
 144                 IEEE80211_ERROR("Unable to allocate network device.\n");
 145                 goto failed;
 146         }
 147         ieee = netdev_priv(dev);
 148         dev->hard_start_xmit = ieee80211_xmit;
 149         dev->change_mtu = ieee80211_change_mtu;
 150
 151         /* Drivers are free to override this if the generic implementation
 152          * does not meet their needs. */
 153         dev->get_stats = ieee80211_generic_get_stats;
 154
 155         ieee->dev = dev;
 156
 157         err = ieee80211_networks_allocate(ieee);
 158         if (err) {
 159                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n", err);
 160                 goto failed;
 161         }
 162         ieee80211_networks_initialize(ieee);
 163
 164         /* Default fragmentation threshold is maximum payload size */
 165         ieee->fts = DEFAULT_FTS;
 166         ieee->rts = DEFAULT_FTS;
 167         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 168         ieee->open_wep = 1;
 169
 170         /* Default to enabling full open WEP with host based encrypt/decrypt */
 171         ieee->host_encrypt = 1;
 172         ieee->host_decrypt = 1;
 173         ieee->host_mc_decrypt = 1;
 174
 175         /* Host fragementation in Open mode. Default is enabled.
 176          * Note: host fragmentation is always enabled if host encryption
 177          * is enabled. For cards can do hardware encryption, they must do
 178          * hardware fragmentation as well. So we don't need a variable
 179          * like host_enc_frag. */
 180         ieee->host_open_frag = 1;
 181         ieee->ieee802_1x = 1;   /* Default to supporting 802.1x */
 182
 183         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
 184         init_timer(&ieee->crypt_deinit_timer);
 185         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
 186         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
 187         ieee->crypt_quiesced = 0;
 188
 189         spin_lock_init(&ieee->lock);
 190
 191         ieee->wpa_enabled = 0;
 192         ieee->drop_unencrypted = 0;
 193         ieee->privacy_invoked = 0;
 194
 195         return dev;
 196
 197       failed:
 198         if (dev)
 199                 free_netdev(dev);
 200         return NULL;
 201 }
 202
 203 void free_ieee80211(struct net_device *dev)
 204 {
 205         struct ieee80211_device *ieee = netdev_priv(dev);
 206
 207         int i;
 208
 209         ieee80211_crypt_quiescing(ieee);
 210         del_timer_sync(&ieee->crypt_deinit_timer);
 211         ieee80211_crypt_deinit_entries(ieee, 1);
 212
 213         for (i = 0; i < WEP_KEYS; i++) {
 214                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 215                 if (crypt) {
 216                         if (crypt->ops) {
 217                                 crypt->ops->deinit(crypt->priv);
 218                                 module_put(crypt->ops->owner);
 219                         }
 220                         kfree(crypt);
 221                         ieee->crypt[i] = NULL;
 222                 }
 223         }
 224
 225         ieee80211_networks_free(ieee);
 226         free_netdev(dev);
 227 }
 228
 229 #ifdef CONFIG_IEEE80211_DEBUG
 230
 231 static int debug = 0;
 232 u32 ieee80211_debug_level = 0;
 233 EXPORT_SYMBOL_GPL(ieee80211_debug_level);
 234 static struct proc_dir_entry *ieee80211_proc = NULL;
 235
 236 static int show_debug_level(char *page, char **start, off_t offset,
 237                             int count, int *eof, void *data)
 238 {
 239         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 240 }
 241
 242 static int store_debug_level(struct file *file, const char __user * buffer,
 243                              unsigned long count, void *data)
 244 {
 245         char buf[] = "0x00000000\n";
 246         unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
 247         unsigned long val;
 248
 249         if (copy_from_user(buf, buffer, len))
 250                 return count;
 251         buf[len] = 0;
 252         if (sscanf(buf, "%li", &val) != 1)
 253                 printk(KERN_INFO DRV_NAME
 254                        ": %s is not in hex or decimal form.\n", buf);
 255         else
 256                 ieee80211_debug_level = val;
 257
 258         return strnlen(buf, len);
 259 }
 260 #endif                          /* CONFIG_IEEE80211_DEBUG */
 261
 262 static int __init ieee80211_init(void)
 263 {
 264 #ifdef CONFIG_IEEE80211_DEBUG
 265         struct proc_dir_entry *e;
 266
 267         ieee80211_debug_level = debug;
 268         ieee80211_proc = proc_mkdir(DRV_NAME, init_net.proc_net);
 269         if (ieee80211_proc == NULL) {
 270                 IEEE80211_ERROR("Unable to create " DRV_NAME
 271                                 " proc directory\n");
 272                 return -EIO;
 273         }
 274         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 275                               ieee80211_proc);
 276         if (!e) {
 277                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 278                 ieee80211_proc = NULL;
 279                 return -EIO;
 280         }
 281         e->read_proc = show_debug_level;
 282         e->write_proc = store_debug_level;
 283         e->data = NULL;
 284 #endif                          /* CONFIG_IEEE80211_DEBUG */
 285
 286         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
 287         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
 288
 289         return 0;
 290 }
 291
 292 static void __exit ieee80211_exit(void)
 293 {
 294 #ifdef CONFIG_IEEE80211_DEBUG
 295         if (ieee80211_proc) {
 296                 remove_proc_entry("debug_level", ieee80211_proc);
 297                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 298                 ieee80211_proc = NULL;
 299         }
 300 #endif                          /* CONFIG_IEEE80211_DEBUG */
 301 }
 302
 303 #ifdef CONFIG_IEEE80211_DEBUG
 304 #include <linux/moduleparam.h>
 305 module_param(debug, int, 0444);
 306 MODULE_PARM_DESC(debug, "debug output mask");
 307 #endif                          /* CONFIG_IEEE80211_DEBUG */
 308
 309 module_exit(ieee80211_exit);
 310 module_init(ieee80211_init);
 311
 312 const char *escape_essid(const char *essid, u8 essid_len)
 313 {
 314         static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
 315         const char *s = essid;
 316         char *d = escaped;
 317
 318         if (ieee80211_is_empty_essid(essid, essid_len)) {
 319                 memcpy(escaped, "<hidden>", sizeof("<hidden>"));
 320                 return escaped;
 321         }
 322
 323         essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
 324         while (essid_len--) {
 325                 if (*s == '\0') {
 326                         *d++ = '\\';
 327                         *d++ = '0';
 328                         s++;
 329                 } else {
 330                         *d++ = *s++;
 331                 }
 332         }
 333         *d = '\0';
 334         return escaped;
 335 }
 336
 337 EXPORT_SYMBOL(alloc_ieee80211);
 338 EXPORT_SYMBOL(free_ieee80211);
 339 EXPORT_SYMBOL(escape_essid);