[CRYPTO] cryptomgr: Fix parsing of nested templates
[linux-3.10.git] / crypto / cryptomgr.c
1 /*
2  * Create default crypto algorithm instances.
3  *
4  * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the Free
8  * Software Foundation; either version 2 of the License, or (at your option)
9  * any later version.
10  *
11  */
12
13 #include <linux/crypto.h>
14 #include <linux/ctype.h>
15 #include <linux/err.h>
16 #include <linux/init.h>
17 #include <linux/kthread.h>
18 #include <linux/module.h>
19 #include <linux/notifier.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/sched.h>
22 #include <linux/string.h>
23
24 #include "internal.h"
25
26 struct cryptomgr_param {
27         struct task_struct *thread;
28
29         struct rtattr *tb[CRYPTOA_MAX];
30
31         struct {
32                 struct rtattr attr;
33                 struct crypto_attr_type data;
34         } type;
35
36         struct {
37                 struct rtattr attr;
38                 struct crypto_attr_alg data;
39         } alg;
40
41         struct {
42                 char name[CRYPTO_MAX_ALG_NAME];
43         } larval;
44
45         char template[CRYPTO_MAX_ALG_NAME];
46 };
47
48 static int cryptomgr_probe(void *data)
49 {
50         struct cryptomgr_param *param = data;
51         struct crypto_template *tmpl;
52         struct crypto_instance *inst;
53         int err;
54
55         tmpl = crypto_lookup_template(param->template);
56         if (!tmpl)
57                 goto err;
58
59         do {
60                 inst = tmpl->alloc(param->tb);
61                 if (IS_ERR(inst))
62                         err = PTR_ERR(inst);
63                 else if ((err = crypto_register_instance(tmpl, inst)))
64                         tmpl->free(inst);
65         } while (err == -EAGAIN && !signal_pending(current));
66
67         crypto_tmpl_put(tmpl);
68
69         if (err)
70                 goto err;
71
72 out:
73         kfree(param);
74         module_put_and_exit(0);
75
76 err:
77         crypto_larval_error(param->larval.name, param->type.data.type,
78                             param->type.data.mask);
79         goto out;
80 }
81
82 static int cryptomgr_schedule_probe(struct crypto_larval *larval)
83 {
84         struct cryptomgr_param *param;
85         const char *name = larval->alg.cra_name;
86         const char *p;
87         unsigned int len;
88
89         if (!try_module_get(THIS_MODULE))
90                 goto err;
91
92         param = kzalloc(sizeof(*param), GFP_KERNEL);
93         if (!param)
94                 goto err_put_module;
95
96         for (p = name; isalnum(*p) || *p == '-' || *p == '_'; p++)
97                 ;
98
99         len = p - name;
100         if (!len || *p != '(')
101                 goto err_free_param;
102
103         memcpy(param->template, name, len);
104
105         name = p + 1;
106         len = 0;
107         for (p = name; *p; p++) {
108                 for (; isalnum(*p) || *p == '-' || *p == '_' || *p == '('; p++)
109                         ;
110
111                 if (*p != ')')
112                         goto err_free_param;
113
114                 len = p - name;
115         }
116
117         if (!len || name[len + 1])
118                 goto err_free_param;
119
120         param->type.attr.rta_len = sizeof(param->type);
121         param->type.attr.rta_type = CRYPTOA_TYPE;
122         param->type.data.type = larval->alg.cra_flags;
123         param->type.data.mask = larval->mask;
124         param->tb[CRYPTOA_TYPE - 1] = &param->type.attr;
125
126         param->alg.attr.rta_len = sizeof(param->alg);
127         param->alg.attr.rta_type = CRYPTOA_ALG;
128         memcpy(param->alg.data.name, name, len);
129         param->tb[CRYPTOA_ALG - 1] = &param->alg.attr;
130
131         memcpy(param->larval.name, larval->alg.cra_name, CRYPTO_MAX_ALG_NAME);
132
133         param->thread = kthread_run(cryptomgr_probe, param, "cryptomgr");
134         if (IS_ERR(param->thread))
135                 goto err_free_param;
136
137         return NOTIFY_STOP;
138
139 err_free_param:
140         kfree(param);
141 err_put_module:
142         module_put(THIS_MODULE);
143 err:
144         return NOTIFY_OK;
145 }
146
147 static int cryptomgr_notify(struct notifier_block *this, unsigned long msg,
148                             void *data)
149 {
150         switch (msg) {
151         case CRYPTO_MSG_ALG_REQUEST:
152                 return cryptomgr_schedule_probe(data);
153         }
154
155         return NOTIFY_DONE;
156 }
157
158 static struct notifier_block cryptomgr_notifier = {
159         .notifier_call = cryptomgr_notify,
160 };
161
162 static int __init cryptomgr_init(void)
163 {
164         return crypto_register_notifier(&cryptomgr_notifier);
165 }
166
167 static void __exit cryptomgr_exit(void)
168 {
169         int err = crypto_unregister_notifier(&cryptomgr_notifier);
170         BUG_ON(err);
171 }
172
173 module_init(cryptomgr_init);
174 module_exit(cryptomgr_exit);
175
176 MODULE_LICENSE("GPL");
177 MODULE_DESCRIPTION("Crypto Algorithm Manager");