← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to include/crypto/internal/hash.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/crypto/internal/hash.h
 
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