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