~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/crypto/internal/hash.h

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Hash algorithms.
  3  * 
  4  * Copyright (c) 2008 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 #ifndef _CRYPTO_INTERNAL_HASH_H
 14 #define _CRYPTO_INTERNAL_HASH_H
 15 
 16 #include <crypto/algapi.h>
 17 #include <crypto/hash.h>
 18 
 19 struct ahash_request;
 20 struct scatterlist;
 21 
 22 struct crypto_hash_walk {
 23         char *data;
 24 
 25         unsigned int offset;
 26         unsigned int alignmask;
 27 
 28         struct page *pg;
 29         unsigned int entrylen;
 30 
 31         unsigned int total;
 32         struct scatterlist *sg;
 33 
 34         unsigned int flags;
 35 };
 36 
 37 struct ahash_instance {
 38         struct ahash_alg alg;
 39 };
 40 
 41 struct shash_instance {
 42         struct shash_alg alg;
 43 };
 44 
 45 struct crypto_ahash_spawn {
 46         struct crypto_spawn base;
 47 };
 48 
 49 struct crypto_shash_spawn {
 50         struct crypto_spawn base;
 51 };
 52 
 53 extern const struct crypto_type crypto_ahash_type;
 54 
 55 int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
 56 int crypto_hash_walk_first(struct ahash_request *req,
 57                            struct crypto_hash_walk *walk);
 58 int crypto_hash_walk_first_compat(struct hash_desc *hdesc,
 59                                   struct crypto_hash_walk *walk,
 60                                   struct scatterlist *sg, unsigned int len);
 61 
 62 static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
 63 {
 64         return !(walk->entrylen | walk->total);
 65 }
 66 
 67 int crypto_register_ahash(struct ahash_alg *alg);
 68 int crypto_unregister_ahash(struct ahash_alg *alg);
 69 int ahash_register_instance(struct crypto_template *tmpl,
 70                             struct ahash_instance *inst);
 71 void ahash_free_instance(struct crypto_instance *inst);
 72 
 73 int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
 74                             struct hash_alg_common *alg,
 75                             struct crypto_instance *inst);
 76 
 77 static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
 78 {
 79         crypto_drop_spawn(&spawn->base);
 80 }
 81 
 82 struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
 83 
 84 int crypto_register_shash(struct shash_alg *alg);
 85 int crypto_unregister_shash(struct shash_alg *alg);
 86 int shash_register_instance(struct crypto_template *tmpl,
 87                             struct shash_instance *inst);
 88 void shash_free_instance(struct crypto_instance *inst);
 89 
 90 int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
 91                             struct shash_alg *alg,
 92                             struct crypto_instance *inst);
 93 
 94 static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
 95 {
 96         crypto_drop_spawn(&spawn->base);
 97 }
 98 
 99 struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
100 
101 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
102 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
103 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
104 
105 int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
106 
107 static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
108 {
109         return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
110 }
111 
112 static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
113 {
114         return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
115                             halg);
116 }
117 
118 static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
119                                             unsigned int reqsize)
120 {
121         tfm->reqsize = reqsize;
122 }
123 
124 static inline struct crypto_instance *ahash_crypto_instance(
125         struct ahash_instance *inst)
126 {
127         return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
128 }
129 
130 static inline struct ahash_instance *ahash_instance(
131         struct crypto_instance *inst)
132 {
133         return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
134 }
135 
136 static inline void *ahash_instance_ctx(struct ahash_instance *inst)
137 {
138         return crypto_instance_ctx(ahash_crypto_instance(inst));
139 }
140 
141 static inline unsigned int ahash_instance_headroom(void)
142 {
143         return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
144 }
145 
146 static inline struct ahash_instance *ahash_alloc_instance(
147         const char *name, struct crypto_alg *alg)
148 {
149         return crypto_alloc_instance2(name, alg, ahash_instance_headroom());
150 }
151 
152 static inline struct crypto_ahash *crypto_spawn_ahash(
153         struct crypto_ahash_spawn *spawn)
154 {
155         return crypto_spawn_tfm2(&spawn->base);
156 }
157 
158 static inline int ahash_enqueue_request(struct crypto_queue *queue,
159                                              struct ahash_request *request)
160 {
161         return crypto_enqueue_request(queue, &request->base);
162 }
163 
164 static inline struct ahash_request *ahash_dequeue_request(
165         struct crypto_queue *queue)
166 {
167         return ahash_request_cast(crypto_dequeue_request(queue));
168 }
169 
170 static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
171                                           struct crypto_ahash *tfm)
172 {
173         return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
174 }
175 
176 static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
177 {
178         return crypto_tfm_ctx(&tfm->base);
179 }
180 
181 static inline struct crypto_instance *shash_crypto_instance(
182         struct shash_instance *inst)
183 {
184         return container_of(&inst->alg.base, struct crypto_instance, alg);
185 }
186 
187 static inline struct shash_instance *shash_instance(
188         struct crypto_instance *inst)
189 {
190         return container_of(__crypto_shash_alg(&inst->alg),
191                             struct shash_instance, alg);
192 }
193 
194 static inline void *shash_instance_ctx(struct shash_instance *inst)
195 {
196         return crypto_instance_ctx(shash_crypto_instance(inst));
197 }
198 
199 static inline struct shash_instance *shash_alloc_instance(
200         const char *name, struct crypto_alg *alg)
201 {
202         return crypto_alloc_instance2(name, alg,
203                                       sizeof(struct shash_alg) - sizeof(*alg));
204 }
205 
206 static inline struct crypto_shash *crypto_spawn_shash(
207         struct crypto_shash_spawn *spawn)
208 {
209         return crypto_spawn_tfm2(&spawn->base);
210 }
211 
212 static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
213 {
214         return crypto_tfm_ctx_aligned(&tfm->base);
215 }
216 
217 static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
218 {
219         return container_of(tfm, struct crypto_shash, base);
220 }
221 
222 #endif  /* _CRYPTO_INTERNAL_HASH_H */
223 
224 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp