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("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
  58 MODULE_LICENSE("GPL");
  59
  60 #define DRV_NAME "ieee80211"
  61
  62 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
  63 {
  64         if (ieee->networks)
  65                 return 0;
  66
  67         ieee->networks = kmalloc(
  68                 MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
  69                 GFP_KERNEL);
  70         if (!ieee->networks) {
  71                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
  72                        ieee->dev->name);
  73                 return -ENOMEM;
  74         }
  75
  76         memset(ieee->networks, 0,
  77                MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));
  78
  79         return 0;
  80 }
  81
  82 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
  83 {
  84         if (!ieee->networks)
  85                 return;
  86         kfree(ieee->networks);
  87         ieee->networks = NULL;
  88 }
  89
  90 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
  91 {
  92         int i;
  93
  94         INIT_LIST_HEAD(&ieee->network_free_list);
  95         INIT_LIST_HEAD(&ieee->network_list);
  96         for (i = 0; i < MAX_NETWORK_COUNT; i++)
  97                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
  98 }
  99
 100
 101 struct net_device *alloc_ieee80211(int sizeof_priv)
 102 {
 103         struct ieee80211_device *ieee;
 104         struct net_device *dev;
 105         int err;
 106
 107         IEEE80211_DEBUG_INFO("Initializing...\n");
 108
 109         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 110         if (!dev) {
 111                 IEEE80211_ERROR("Unable to network device.\n");
 112                 goto failed;
 113         }
 114         ieee = netdev_priv(dev);
 115         dev->hard_start_xmit = ieee80211_xmit;
 116
 117         ieee->dev = dev;
 118
 119         err = ieee80211_networks_allocate(ieee);
 120         if (err) {
 121                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
 122                                 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
 159 void free_ieee80211(struct net_device *dev)
 160 {
 161         struct ieee80211_device *ieee = netdev_priv(dev);
 162
 163         int i;
 164
 165         del_timer_sync(&ieee->crypt_deinit_timer);
 166         ieee80211_crypt_deinit_entries(ieee, 1);
 167
 168         for (i = 0; i < WEP_KEYS; i++) {
 169                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 170                 if (crypt) {
 171                         if (crypt->ops) {
 172                                 crypt->ops->deinit(crypt->priv);
 173                                 module_put(crypt->ops->owner);
 174                         }
 175                         kfree(crypt);
 176                         ieee->crypt[i] = NULL;
 177                 }
 178         }
 179
 180         ieee80211_networks_free(ieee);
 181         free_netdev(dev);
 182 }
 183
 184 #ifdef CONFIG_IEEE80211_DEBUG
 185
 186 static int debug = 0;
 187 u32 ieee80211_debug_level = 0;
 188 struct proc_dir_entry *ieee80211_proc = NULL;
 189
 190 static int show_debug_level(char *page, char **start, off_t offset,
 191                             int count, int *eof, void *data)
 192 {
 193         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 194 }
 195
 196 static int store_debug_level(struct file *file, const char __user *buffer,
 197                              unsigned long count, void *data)
 198 {
 199         char buf[] = "0x00000000";
 200         char *p = (char *)buf;
 201         unsigned long val;
 202
 203         if (count > sizeof(buf) - 1)
 204                 count = sizeof(buf) - 1;
 205
 206         if (copy_from_user(buf, buffer, count))
 207                 return count;
 208         buf[count] = 0;
 209         /*
 210          * what a FPOS...  What, sscanf(buf, "%i", &val) would be too
 211          * scary?
 212          */
 213         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
 214                 p++;
 215                 if (p[0] == 'x' || p[0] == 'X')
 216                         p++;
 217                 val = simple_strtoul(p, &p, 16);
 218         } else
 219                 val = simple_strtoul(p, &p, 10);
 220         if (p == buf)
 221                 printk(KERN_INFO DRV_NAME
 222                        ": %s is not in hex or decimal form.\n", buf);
 223         else
 224                 ieee80211_debug_level = val;
 225
 226         return strlen(buf);
 227 }
 228
 229 static int __init ieee80211_init(void)
 230 {
 231         struct proc_dir_entry *e;
 232
 233         ieee80211_debug_level = debug;
 234         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
 235         if (ieee80211_proc == NULL) {
 236                 IEEE80211_ERROR("Unable to create " DRV_NAME
 237                                 " proc directory\n");
 238                 return -EIO;
 239         }
 240         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 241                               ieee80211_proc);
 242         if (!e) {
 243                 remove_proc_entry(DRV_NAME, proc_net);
 244                 ieee80211_proc = NULL;
 245                 return -EIO;
 246         }
 247         e->read_proc = show_debug_level;
 248         e->write_proc = store_debug_level;
 249         e->data = NULL;
 250
 251         return 0;
 252 }
 253
 254 static void __exit ieee80211_exit(void)
 255 {
 256         if (ieee80211_proc) {
 257                 remove_proc_entry("debug_level", ieee80211_proc);
 258                 remove_proc_entry(DRV_NAME, proc_net);
 259                 ieee80211_proc = NULL;
 260         }
 261 }
 262
 263 #include <linux/moduleparam.h>
 264 module_param(debug, int, 0444);
 265 MODULE_PARM_DESC(debug, "debug output mask");
 266
 267
 268 module_exit(ieee80211_exit);
 269 module_init(ieee80211_init);
 270 #endif
 271
 272
 273 const char *escape_essid(const char *essid, u8 essid_len) {
 274         static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
 275         const char *s = essid;
 276         char *d = escaped;
 277
 278         if (ieee80211_is_empty_essid(essid, essid_len)) {
 279                 memcpy(escaped, "<hidden>", sizeof("<hidden>"));
 280                 return escaped;
 281         }
 282
 283         essid_len = min(essid_len, (u8)IW_ESSID_MAX_SIZE);
 284         while (essid_len--) {
 285                 if (*s == '\0') {
 286                         *d++ = '\\';
 287                         *d++ = '0';
 288                         s++;
 289                 } else {
 290                         *d++ = *s++;
 291                 }
 292         }
 293         *d = '\0';
 294         return escaped;
 295 }
 296
 297 EXPORT_SYMBOL(alloc_ieee80211);
 298 EXPORT_SYMBOL(free_ieee80211);
 299 EXPORT_SYMBOL(escape_essid);