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->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         ieee->crypt_quiesced = 0;
 143
 144         spin_lock_init(&ieee->lock);
 145
 146         ieee->wpa_enabled = 0;
 147         ieee->tkip_countermeasures = 0;
 148         ieee->drop_unencrypted = 0;
 149         ieee->privacy_invoked = 0;
 150         ieee->ieee802_1x = 1;
 151
 152         return dev;
 153
 154       failed:
 155         if (dev)
 156                 free_netdev(dev);
 157         return NULL;
 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         ieee80211_crypt_quiescing(ieee);
 167         del_timer_sync(&ieee->crypt_deinit_timer);
 168         ieee80211_crypt_deinit_entries(ieee, 1);
 169
 170         for (i = 0; i < WEP_KEYS; i++) {
 171                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 172                 if (crypt) {
 173                         if (crypt->ops) {
 174                                 crypt->ops->deinit(crypt->priv);
 175                                 module_put(crypt->ops->owner);
 176                         }
 177                         kfree(crypt);
 178                         ieee->crypt[i] = NULL;
 179                 }
 180         }
 181
 182         ieee80211_networks_free(ieee);
 183         free_netdev(dev);
 184 }
 185
 186 #ifdef CONFIG_IEEE80211_DEBUG
 187
 188 static int debug = 0;
 189 u32 ieee80211_debug_level = 0;
 190 struct proc_dir_entry *ieee80211_proc = NULL;
 191
 192 static int show_debug_level(char *page, char **start, off_t offset,
 193                             int count, int *eof, void *data)
 194 {
 195         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 196 }
 197
 198 static int store_debug_level(struct file *file, const char __user * buffer,
 199                              unsigned long count, void *data)
 200 {
 201         char buf[] = "0x00000000\n";
 202         unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
 203         unsigned long val;
 204
 205         if (copy_from_user(buf, buffer, len))
 206                 return count;
 207         buf[len] = 0;
 208         if (sscanf(buf, "%li", &val) != 1)
 209                 printk(KERN_INFO DRV_NAME
 210                        ": %s is not in hex or decimal form.\n", buf);
 211         else
 212                 ieee80211_debug_level = val;
 213
 214         return strnlen(buf, len);
 215 }
 216
 217 static int __init ieee80211_init(void)
 218 {
 219         struct proc_dir_entry *e;
 220
 221         ieee80211_debug_level = debug;
 222         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
 223         if (ieee80211_proc == NULL) {
 224                 IEEE80211_ERROR("Unable to create " DRV_NAME
 225                                 " proc directory\n");
 226                 return -EIO;
 227         }
 228         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 229                               ieee80211_proc);
 230         if (!e) {
 231                 remove_proc_entry(DRV_NAME, proc_net);
 232                 ieee80211_proc = NULL;
 233                 return -EIO;
 234         }
 235         e->read_proc = show_debug_level;
 236         e->write_proc = store_debug_level;
 237         e->data = NULL;
 238
 239         return 0;
 240 }
 241
 242 static void __exit ieee80211_exit(void)
 243 {
 244         if (ieee80211_proc) {
 245                 remove_proc_entry("debug_level", ieee80211_proc);
 246                 remove_proc_entry(DRV_NAME, proc_net);
 247                 ieee80211_proc = NULL;
 248         }
 249 }
 250
 251 #include <linux/moduleparam.h>
 252 module_param(debug, int, 0444);
 253 MODULE_PARM_DESC(debug, "debug output mask");
 254
 255 module_exit(ieee80211_exit);
 256 module_init(ieee80211_init);
 257 #endif
 258
 259 const char *escape_essid(const char *essid, u8 essid_len)
 260 {
 261         static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
 262         const char *s = essid;
 263         char *d = escaped;
 264
 265         if (ieee80211_is_empty_essid(essid, essid_len)) {
 266                 memcpy(escaped, "<hidden>", sizeof("<hidden>"));
 267                 return escaped;
 268         }
 269
 270         essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
 271         while (essid_len--) {
 272                 if (*s == '\0') {
 273                         *d++ = '\\';
 274                         *d++ = '0';
 275                         s++;
 276                 } else {
 277                         *d++ = *s++;
 278                 }
 279         }
 280         *d = '\0';
 281         return escaped;
 282 }
 283
 284 EXPORT_SYMBOL(alloc_ieee80211);
 285 EXPORT_SYMBOL(free_ieee80211);
 286 EXPORT_SYMBOL(escape_essid);