more debug output
[linux-2.4.git] / crypto / 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öller.
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 <linux/init.h>
17 #include <linux/crypto.h>
18 #include <linux/errno.h>
19 #include <linux/rwsem.h>
20 #include <linux/slab.h>
21 #include "internal.h"
22
23 LIST_HEAD(crypto_alg_list);
24 DECLARE_RWSEM(crypto_alg_sem);
25
26 static inline int crypto_alg_get(struct crypto_alg *alg)
27 {
28         return try_inc_mod_count(alg->cra_module);
29 }
30
31 static inline void crypto_alg_put(struct crypto_alg *alg)
32 {
33         if (alg->cra_module)
34                 __MOD_DEC_USE_COUNT(alg->cra_module);
35 }
36
37 struct crypto_alg *crypto_alg_lookup(const char *name)
38 {
39         struct crypto_alg *q, *alg = NULL;
40
41         if (!name)
42                 return NULL;
43         
44         down_read(&crypto_alg_sem);
45         
46         list_for_each_entry(q, &crypto_alg_list, cra_list) {
47                 if (!(strcmp(q->cra_name, name))) {
48                         if (crypto_alg_get(q))
49                                 alg = q;
50                         break;
51                 }
52         }
53         
54         up_read(&crypto_alg_sem);
55         return alg;
56 }
57
58 static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
59 {
60         tfm->crt_flags = 0;
61         
62         switch (crypto_tfm_alg_type(tfm)) {
63         case CRYPTO_ALG_TYPE_CIPHER:
64                 return crypto_init_cipher_flags(tfm, flags);
65                 
66         case CRYPTO_ALG_TYPE_DIGEST:
67                 return crypto_init_digest_flags(tfm, flags);
68                 
69         case CRYPTO_ALG_TYPE_COMPRESS:
70                 return crypto_init_compress_flags(tfm, flags);
71         
72         default:
73                 break;
74         }
75         
76         BUG();
77         return -EINVAL;
78 }
79
80 static int crypto_init_ops(struct crypto_tfm *tfm)
81 {
82         switch (crypto_tfm_alg_type(tfm)) {
83         case CRYPTO_ALG_TYPE_CIPHER:
84                 return crypto_init_cipher_ops(tfm);
85                 
86         case CRYPTO_ALG_TYPE_DIGEST:
87                 return crypto_init_digest_ops(tfm);
88                 
89         case CRYPTO_ALG_TYPE_COMPRESS:
90                 return crypto_init_compress_ops(tfm);
91         
92         default:
93                 break;
94         }
95         
96         BUG();
97         return -EINVAL;
98 }
99
100 static void crypto_exit_ops(struct crypto_tfm *tfm)
101 {
102         switch (crypto_tfm_alg_type(tfm)) {
103         case CRYPTO_ALG_TYPE_CIPHER:
104                 crypto_exit_cipher_ops(tfm);
105                 break;
106                 
107         case CRYPTO_ALG_TYPE_DIGEST:
108                 crypto_exit_digest_ops(tfm);
109                 break;
110                 
111         case CRYPTO_ALG_TYPE_COMPRESS:
112                 crypto_exit_compress_ops(tfm);
113                 break;
114         
115         default:
116                 BUG();
117                 
118         }
119 }
120
121 struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
122 {
123         struct crypto_tfm *tfm = NULL;
124         struct crypto_alg *alg;
125
126         alg = crypto_alg_mod_lookup(name);
127         if (alg == NULL)
128                 goto out;
129         
130         tfm = kmalloc(sizeof(*tfm) + alg->cra_ctxsize, GFP_KERNEL);
131         if (tfm == NULL)
132                 goto out_put;
133
134         memset(tfm, 0, sizeof(*tfm) + alg->cra_ctxsize);
135         
136         tfm->__crt_alg = alg;
137         
138         if (crypto_init_flags(tfm, flags))
139                 goto out_free_tfm;
140                 
141         if (crypto_init_ops(tfm)) {
142                 crypto_exit_ops(tfm);
143                 goto out_free_tfm;
144         }
145
146         goto out;
147
148 out_free_tfm:
149         kfree(tfm);
150         tfm = NULL;
151 out_put:
152         crypto_alg_put(alg);
153 out:
154         return tfm;
155 }
156
157 void crypto_free_tfm(struct crypto_tfm *tfm)
158 {
159         struct crypto_alg *alg = tfm->__crt_alg;
160         int size = sizeof(*tfm) + alg->cra_ctxsize;
161
162         crypto_exit_ops(tfm);
163         crypto_alg_put(alg);
164         memset(tfm, 0, size);
165         kfree(tfm);
166 }
167
168 int crypto_register_alg(struct crypto_alg *alg)
169 {
170         int ret = 0;
171         struct crypto_alg *q;
172         
173         down_write(&crypto_alg_sem);
174         
175         list_for_each_entry(q, &crypto_alg_list, cra_list) {
176                 if (!(strcmp(q->cra_name, alg->cra_name))) {
177                         ret = -EEXIST;
178                         goto out;
179                 }
180         }
181         
182         list_add_tail(&alg->cra_list, &crypto_alg_list);
183 out:    
184         up_write(&crypto_alg_sem);
185         return ret;
186 }
187
188 int crypto_unregister_alg(struct crypto_alg *alg)
189 {
190         int ret = -ENOENT;
191         struct crypto_alg *q;
192         
193         BUG_ON(!alg->cra_module);
194         
195         down_write(&crypto_alg_sem);
196         list_for_each_entry(q, &crypto_alg_list, cra_list) {
197                 if (alg == q) {
198                         list_del(&alg->cra_list);
199                         ret = 0;
200                         goto out;
201                 }
202         }
203 out:    
204         up_write(&crypto_alg_sem);
205         return ret;
206 }
207
208 int crypto_alg_available(const char *name, u32 flags)
209 {
210         int ret = 0;
211         struct crypto_alg *alg = crypto_alg_mod_lookup(name);
212         
213         if (alg) {
214                 crypto_alg_put(alg);
215                 ret = 1;
216         }
217         
218         return ret;
219 }
220
221 static int __init init_crypto(void)
222 {
223         printk(KERN_INFO "Initializing Cryptographic API\n");
224         crypto_init_proc();
225         return 0;
226 }
227
228 __initcall(init_crypto);
229
230 EXPORT_SYMBOL_GPL(crypto_register_alg);
231 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
232 EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
233 EXPORT_SYMBOL_GPL(crypto_free_tfm);
234 EXPORT_SYMBOL_GPL(crypto_alg_available);