1 /* 2 * lib80211.h -- common bits for IEEE802.11 wireless drivers 3 * 4 * Copyright (c) 2008, John W. Linville <linville@tuxdriver.com> 5 * 6 * Some bits copied from old ieee80211 component, w/ original copyright 7 * notices below: 8 * 9 * Original code based on Host AP (software wireless LAN access point) driver 10 * for Intersil Prism2/2.5/3. 11 * 12 * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen 13 * <j@w1.fi> 14 * Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi> 15 * 16 * Adaption to a generic IEEE 802.11 stack by James Ketrenos 17 * <jketreno@linux.intel.com> 18 * 19 * Copyright (c) 2004, Intel Corporation 20 * 21 */ 22 23 #ifndef LIB80211_H 24 #define LIB80211_H 25 26 #include <linux/types.h> 27 #include <linux/list.h> 28 #include <linux/module.h> 29 #include <asm/atomic.h> 30 #include <linux/if.h> 31 #include <linux/skbuff.h> 32 #include <linux/ieee80211.h> 33 #include <linux/timer.h> 34 /* print_ssid() is intended to be used in debug (and possibly error) 35 * messages. It should never be used for passing ssid to user space. */ 36 const char *print_ssid(char *buf, const char *ssid, u8 ssid_len); 37 #define DECLARE_SSID_BUF(var) char var[IEEE80211_MAX_SSID_LEN * 4 + 1] __maybe_unused 38 39 #define NUM_WEP_KEYS 4 40 41 enum { 42 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES = (1 << 0), 43 }; 44 45 struct lib80211_crypto_ops { 46 const char *name; 47 struct list_head list; 48 49 /* init new crypto context (e.g., allocate private data space, 50 * select IV, etc.); returns NULL on failure or pointer to allocated 51 * private data on success */ 52 void *(*init) (int keyidx); 53 54 /* deinitialize crypto context and free allocated private data */ 55 void (*deinit) (void *priv); 56 57 int (*build_iv) (struct sk_buff * skb, int hdr_len, 58 u8 *key, int keylen, void *priv); 59 60 /* encrypt/decrypt return < 0 on error or >= 0 on success. The return 61 * value from decrypt_mpdu is passed as the keyidx value for 62 * decrypt_msdu. skb must have enough head and tail room for the 63 * encryption; if not, error will be returned; these functions are 64 * called for all MPDUs (i.e., fragments). 65 */ 66 int (*encrypt_mpdu) (struct sk_buff * skb, int hdr_len, void *priv); 67 int (*decrypt_mpdu) (struct sk_buff * skb, int hdr_len, void *priv); 68 69 /* These functions are called for full MSDUs, i.e. full frames. 70 * These can be NULL if full MSDU operations are not needed. */ 71 int (*encrypt_msdu) (struct sk_buff * skb, int hdr_len, void *priv); 72 int (*decrypt_msdu) (struct sk_buff * skb, int keyidx, int hdr_len, 73 void *priv); 74 75 int (*set_key) (void *key, int len, u8 * seq, void *priv); 76 int (*get_key) (void *key, int len, u8 * seq, void *priv); 77 78 /* procfs handler for printing out key information and possible 79 * statistics */ 80 char *(*print_stats) (char *p, void *priv); 81 82 /* Crypto specific flag get/set for configuration settings */ 83 unsigned long (*get_flags) (void *priv); 84 unsigned long (*set_flags) (unsigned long flags, void *priv); 85 86 /* maximum number of bytes added by encryption; encrypt buf is 87 * allocated with extra_prefix_len bytes, copy of in_buf, and 88 * extra_postfix_len; encrypt need not use all this space, but 89 * the result must start at the beginning of the buffer and correct 90 * length must be returned */ 91 int extra_mpdu_prefix_len, extra_mpdu_postfix_len; 92 int extra_msdu_prefix_len, extra_msdu_postfix_len; 93 94 struct module *owner; 95 }; 96 97 struct lib80211_crypt_data { 98 struct list_head list; /* delayed deletion list */ 99 struct lib80211_crypto_ops *ops; 100 void *priv; 101 atomic_t refcnt; 102 }; 103 104 struct lib80211_crypt_info { 105 char *name; 106 /* Most clients will already have a lock, 107 so just point to that. */ 108 spinlock_t *lock; 109 110 struct lib80211_crypt_data *crypt[NUM_WEP_KEYS]; 111 int tx_keyidx; /* default TX key index (crypt[tx_keyidx]) */ 112 struct list_head crypt_deinit_list; 113 struct timer_list crypt_deinit_timer; 114 int crypt_quiesced; 115 }; 116 117 int lib80211_crypt_info_init(struct lib80211_crypt_info *info, char *name, 118 spinlock_t *lock); 119 void lib80211_crypt_info_free(struct lib80211_crypt_info *info); 120 int lib80211_register_crypto_ops(struct lib80211_crypto_ops *ops); 121 int lib80211_unregister_crypto_ops(struct lib80211_crypto_ops *ops); 122 struct lib80211_crypto_ops *lib80211_get_crypto_ops(const char *name); 123 void lib80211_crypt_deinit_entries(struct lib80211_crypt_info *, int); 124 void lib80211_crypt_deinit_handler(unsigned long); 125 void lib80211_crypt_delayed_deinit(struct lib80211_crypt_info *info, 126 struct lib80211_crypt_data **crypt); 127 void lib80211_crypt_quiescing(struct lib80211_crypt_info *info); 128 129 #endif /* LIB80211_H */ 130