drivers/staging/rtl8192u/ieee80211/api.c

   1 /*
   2  * Scatterlist Cryptographic API.
   3  *
   4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   5  * Copyright (c) 2002 David S. Miller (davem@redhat.com)
   6  *
   7  * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
   8  * and Nettle, by Niels M鰈ler.
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the Free
  12  * Software Foundation; either version 2 of the License, or (at your option)
  13  * any later version.
  14  *
  15  */
  16 #include "kmap_types.h"
  17
  18 #include <linux/init.h>
  19 #include <linux/module.h>
  20 //#include <linux/crypto.h>
  21 #include "rtl_crypto.h"
  22 #include <linux/errno.h>
  23 #include <linux/rwsem.h>
  24 #include <linux/slab.h>
  25 #include "internal.h"
  26
  27 LIST_HEAD(crypto_alg_list);
  28 DECLARE_RWSEM(crypto_alg_sem);
  29
  30 static inline int crypto_alg_get(struct crypto_alg *alg)
  31 {
  32         return try_inc_mod_count(alg->cra_module);
  33 }
  34
  35 static inline void crypto_alg_put(struct crypto_alg *alg)
  36 {
  37         if (alg->cra_module)
  38                 __MOD_DEC_USE_COUNT(alg->cra_module);
  39 }
  40
  41 struct crypto_alg *crypto_alg_lookup(const char *name)
  42 {
  43         struct crypto_alg *q, *alg = NULL;
  44
  45         if (!name)
  46                 return NULL;
  47
  48         down_read(&crypto_alg_sem);
  49
  50         list_for_each_entry(q, &crypto_alg_list, cra_list) {
  51                 if (!(strcmp(q->cra_name, name))) {
  52                         if (crypto_alg_get(q))
  53                                 alg = q;
  54                         break;
  55                 }
  56         }
  57
  58         up_read(&crypto_alg_sem);
  59         return alg;
  60 }
  61
  62 static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
  63 {
  64         tfm->crt_flags = 0;
  65
  66         switch (crypto_tfm_alg_type(tfm)) {
  67         case CRYPTO_ALG_TYPE_CIPHER:
  68                 return crypto_init_cipher_flags(tfm, flags);
  69
  70         case CRYPTO_ALG_TYPE_DIGEST:
  71                 return crypto_init_digest_flags(tfm, flags);
  72
  73         case CRYPTO_ALG_TYPE_COMPRESS:
  74                 return crypto_init_compress_flags(tfm, flags);
  75
  76         default:
  77                 break;
  78         }
  79
  80         BUG();
  81         return -EINVAL;
  82 }
  83
  84 static int crypto_init_ops(struct crypto_tfm *tfm)
  85 {
  86         switch (crypto_tfm_alg_type(tfm)) {
  87         case CRYPTO_ALG_TYPE_CIPHER:
  88                 return crypto_init_cipher_ops(tfm);
  89
  90         case CRYPTO_ALG_TYPE_DIGEST:
  91                 return crypto_init_digest_ops(tfm);
  92
  93         case CRYPTO_ALG_TYPE_COMPRESS:
  94                 return crypto_init_compress_ops(tfm);
  95
  96         default:
  97                 break;
  98         }
  99
 100         BUG();
 101         return -EINVAL;
 102 }
 103
 104 static void crypto_exit_ops(struct crypto_tfm *tfm)
 105 {
 106         switch (crypto_tfm_alg_type(tfm)) {
 107         case CRYPTO_ALG_TYPE_CIPHER:
 108                 crypto_exit_cipher_ops(tfm);
 109                 break;
 110
 111         case CRYPTO_ALG_TYPE_DIGEST:
 112                 crypto_exit_digest_ops(tfm);
 113                 break;
 114
 115         case CRYPTO_ALG_TYPE_COMPRESS:
 116                 crypto_exit_compress_ops(tfm);
 117                 break;
 118
 119         default:
 120                 BUG();
 121
 122         }
 123 }
 124
 125 struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
 126 {
 127         struct crypto_tfm *tfm = NULL;
 128         struct crypto_alg *alg;
 129
 130         alg = crypto_alg_mod_lookup(name);
 131         if (alg == NULL)
 132                 goto out;
 133
 134         tfm = kmalloc(sizeof(*tfm) + alg->cra_ctxsize, GFP_KERNEL);
 135         if (tfm == NULL)
 136                 goto out_put;
 137
 138         memset(tfm, 0, sizeof(*tfm) + alg->cra_ctxsize);
 139
 140         tfm->__crt_alg = alg;
 141
 142         if (crypto_init_flags(tfm, flags))
 143                 goto out_free_tfm;
 144
 145         if (crypto_init_ops(tfm)) {
 146                 crypto_exit_ops(tfm);
 147                 goto out_free_tfm;
 148         }
 149
 150         goto out;
 151
 152 out_free_tfm:
 153         kfree(tfm);
 154         tfm = NULL;
 155 out_put:
 156         crypto_alg_put(alg);
 157 out:
 158         return tfm;
 159 }
 160
 161 void crypto_free_tfm(struct crypto_tfm *tfm)
 162 {
 163         struct crypto_alg *alg = tfm->__crt_alg;
 164         int size = sizeof(*tfm) + alg->cra_ctxsize;
 165
 166         crypto_exit_ops(tfm);
 167         crypto_alg_put(alg);
 168         memset(tfm, 0, size);
 169         kfree(tfm);
 170 }
 171
 172 int crypto_register_alg(struct crypto_alg *alg)
 173 {
 174         int ret = 0;
 175         struct crypto_alg *q;
 176
 177         down_write(&crypto_alg_sem);
 178
 179         list_for_each_entry(q, &crypto_alg_list, cra_list) {
 180                 if (!(strcmp(q->cra_name, alg->cra_name))) {
 181                         ret = -EEXIST;
 182                         goto out;
 183                 }
 184         }
 185
 186         list_add_tail(&alg->cra_list, &crypto_alg_list);
 187 out:
 188         up_write(&crypto_alg_sem);
 189         return ret;
 190 }
 191
 192 int crypto_unregister_alg(struct crypto_alg *alg)
 193 {
 194         int ret = -ENOENT;
 195         struct crypto_alg *q;
 196
 197         BUG_ON(!alg->cra_module);
 198
 199         down_write(&crypto_alg_sem);
 200         list_for_each_entry(q, &crypto_alg_list, cra_list) {
 201                 if (alg == q) {
 202                         list_del(&alg->cra_list);
 203                         ret = 0;
 204                         goto out;
 205                 }
 206         }
 207 out:
 208         up_write(&crypto_alg_sem);
 209         return ret;
 210 }
 211
 212 int crypto_alg_available(const char *name, u32 flags)
 213 {
 214         int ret = 0;
 215         struct crypto_alg *alg = crypto_alg_mod_lookup(name);
 216
 217         if (alg) {
 218                 crypto_alg_put(alg);
 219                 ret = 1;
 220         }
 221
 222         return ret;
 223 }
 224
 225 static int __init init_crypto(void)
 226 {
 227         printk(KERN_INFO "Initializing Cryptographic API\n");
 228         crypto_init_proc();
 229         return 0;
 230 }
 231
 232 __initcall(init_crypto);
 233
 234 /*
 235 EXPORT_SYMBOL_GPL(crypto_register_alg);
 236 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
 237 EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
 238 EXPORT_SYMBOL_GPL(crypto_free_tfm);
 239 EXPORT_SYMBOL_GPL(crypto_alg_available);
 240 */
 241
 242 EXPORT_SYMBOL_NOVERS(crypto_register_alg);
 243 EXPORT_SYMBOL_NOVERS(crypto_unregister_alg);
 244 EXPORT_SYMBOL_NOVERS(crypto_alloc_tfm);
 245 EXPORT_SYMBOL_NOVERS(crypto_free_tfm);
 246 EXPORT_SYMBOL_NOVERS(crypto_alg_available);