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->rts = 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->host_mc_decrypt = 1;
 137
 138         /* Host fragementation in Open mode. Default is enabled.
 139          * Note: host fragmentation is always enabled if host encryption
 140          * is enabled. For cards can do hardware encryption, they must do
 141          * hardware fragmentation as well. So we don't need a variable
 142          * like host_enc_frag. */
 143         ieee->host_open_frag = 1;
 144         ieee->ieee802_1x = 1;   /* Default to supporting 802.1x */
 145
 146         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
 147         init_timer(&ieee->crypt_deinit_timer);
 148         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
 149         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
 150         ieee->crypt_quiesced = 0;
 151
 152         spin_lock_init(&ieee->lock);
 153
 154         ieee->wpa_enabled = 0;
 155         ieee->tkip_countermeasures = 0;
 156         ieee->drop_unencrypted = 0;
 157         ieee->privacy_invoked = 0;
 158
 159         return dev;
 160
 161       failed:
 162         if (dev)
 163                 free_netdev(dev);
 164         return NULL;
 165 }
 166
 167 void free_ieee80211(struct net_device *dev)
 168 {
 169         struct ieee80211_device *ieee = netdev_priv(dev);
 170
 171         int i;
 172
 173         ieee80211_crypt_quiescing(ieee);
 174         del_timer_sync(&ieee->crypt_deinit_timer);
 175         ieee80211_crypt_deinit_entries(ieee, 1);
 176
 177         for (i = 0; i < WEP_KEYS; i++) {
 178                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 179                 if (crypt) {
 180                         if (crypt->ops) {
 181                                 crypt->ops->deinit(crypt->priv);
 182                                 module_put(crypt->ops->owner);
 183                         }
 184                         kfree(crypt);
 185                         ieee->crypt[i] = NULL;
 186                 }
 187         }
 188
 189         ieee80211_networks_free(ieee);
 190         free_netdev(dev);
 191 }
 192
 193 #ifdef CONFIG_IEEE80211_DEBUG
 194
 195 static int debug = 0;
 196 u32 ieee80211_debug_level = 0;
 197 struct proc_dir_entry *ieee80211_proc = NULL;
 198
 199 static int show_debug_level(char *page, char **start, off_t offset,
 200                             int count, int *eof, void *data)
 201 {
 202         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 203 }
 204
 205 static int store_debug_level(struct file *file, const char __user * buffer,
 206                              unsigned long count, void *data)
 207 {
 208         char buf[] = "0x00000000\n";
 209         unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
 210         unsigned long val;
 211
 212         if (copy_from_user(buf, buffer, len))
 213                 return count;
 214         buf[len] = 0;
 215         if (sscanf(buf, "%li", &val) != 1)
 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, len);
 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 module_exit(ieee80211_exit);
 263 module_init(ieee80211_init);
 264 #endif
 265
 266 const char *escape_essid(const char *essid, u8 essid_len)
 267 {
 268         static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
 269         const char *s = essid;
 270         char *d = escaped;
 271
 272         if (ieee80211_is_empty_essid(essid, essid_len)) {
 273                 memcpy(escaped, "<hidden>", sizeof("<hidden>"));
 274                 return escaped;
 275         }
 276
 277         essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
 278         while (essid_len--) {
 279                 if (*s == '\0') {
 280                         *d++ = '\\';
 281                         *d++ = '0';
 282                         s++;
 283                 } else {
 284                         *d++ = *s++;
 285                 }
 286         }
 287         *d = '\0';
 288         return escaped;
 289 }
 290
 291 EXPORT_SYMBOL(alloc_ieee80211);
 292 EXPORT_SYMBOL(free_ieee80211);
 293 EXPORT_SYMBOL(escape_essid);