[linux-2.6-block.git] / include / crypto / internal / hash.h

/*
 * Hash algorithms.
 * 
 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option) 
 * any later version.
 *
 */

#ifndef _CRYPTO_INTERNAL_HASH_H
#define _CRYPTO_INTERNAL_HASH_H

#include <crypto/algapi.h>
#include <crypto/hash.h>

struct ahash_request;
struct scatterlist;

struct crypto_hash_walk {
	char *data;

	unsigned int offset;
	unsigned int alignmask;

	struct page *pg;
	unsigned int entrylen;

	unsigned int total;
	struct scatterlist *sg;

	unsigned int flags;
};

struct ahash_instance {
	struct ahash_alg alg;
};

struct shash_instance {
	struct shash_alg alg;
};

struct crypto_ahash_spawn {
	struct crypto_spawn base;
};

struct crypto_shash_spawn {
	struct crypto_spawn base;
};

extern const struct crypto_type crypto_ahash_type;

int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
int crypto_hash_walk_first(struct ahash_request *req,
			   struct crypto_hash_walk *walk);
int crypto_ahash_walk_first(struct ahash_request *req,
			   struct crypto_hash_walk *walk);

static inline int crypto_ahash_walk_done(struct crypto_hash_walk *walk,
					 int err)
{
	return crypto_hash_walk_done(walk, err);
}

static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
{
	return !(walk->entrylen | walk->total);
}

static inline int crypto_ahash_walk_last(struct crypto_hash_walk *walk)
{
	return crypto_hash_walk_last(walk);
}

int crypto_register_ahash(struct ahash_alg *alg);
int crypto_unregister_ahash(struct ahash_alg *alg);
int crypto_register_ahashes(struct ahash_alg *algs, int count);
void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
int ahash_register_instance(struct crypto_template *tmpl,
			    struct ahash_instance *inst);
void ahash_free_instance(struct crypto_instance *inst);

int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
			    struct hash_alg_common *alg,
			    struct crypto_instance *inst);

static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
{
	crypto_drop_spawn(&spawn->base);
}

struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);

int crypto_register_shash(struct shash_alg *alg);
int crypto_unregister_shash(struct shash_alg *alg);
int crypto_register_shashes(struct shash_alg *algs, int count);
int crypto_unregister_shashes(struct shash_alg *algs, int count);
int shash_register_instance(struct crypto_template *tmpl,
			    struct shash_instance *inst);
void shash_free_instance(struct crypto_instance *inst);

int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
			    struct shash_alg *alg,
			    struct crypto_instance *inst);

static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
{
	crypto_drop_spawn(&spawn->base);
}

struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);

int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);

int ahash_mcryptd_update(struct ahash_request *desc);
int ahash_mcryptd_final(struct ahash_request *desc);
int ahash_mcryptd_finup(struct ahash_request *desc);
int ahash_mcryptd_digest(struct ahash_request *desc);

int crypto_init_shash_ops_async(struct crypto_tfm *tfm);

static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
{
	return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
}

static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
{
	return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
			    halg);
}

static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
					    unsigned int reqsize)
{
	tfm->reqsize = reqsize;
}

static inline struct crypto_instance *ahash_crypto_instance(
	struct ahash_instance *inst)
{
	return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
}

static inline struct ahash_instance *ahash_instance(
	struct crypto_instance *inst)
{
	return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
}

static inline void *ahash_instance_ctx(struct ahash_instance *inst)
{
	return crypto_instance_ctx(ahash_crypto_instance(inst));
}

static inline unsigned int ahash_instance_headroom(void)
{
	return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
}

static inline struct ahash_instance *ahash_alloc_instance(
	const char *name, struct crypto_alg *alg)
{
	return crypto_alloc_instance2(name, alg, ahash_instance_headroom());
}

static inline void ahash_request_complete(struct ahash_request *req, int err)
{
	req->base.complete(&req->base, err);
}

static inline u32 ahash_request_flags(struct ahash_request *req)
{
	return req->base.flags;
}

static inline struct crypto_ahash *crypto_spawn_ahash(
	struct crypto_ahash_spawn *spawn)
{
	return crypto_spawn_tfm2(&spawn->base);
}

static inline int ahash_enqueue_request(struct crypto_queue *queue,
					     struct ahash_request *request)
{
	return crypto_enqueue_request(queue, &request->base);
}

static inline struct ahash_request *ahash_dequeue_request(
	struct crypto_queue *queue)
{
	return ahash_request_cast(crypto_dequeue_request(queue));
}

static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
					  struct crypto_ahash *tfm)
{
	return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
}

static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
{
	return crypto_tfm_ctx(&tfm->base);
}

static inline struct crypto_instance *shash_crypto_instance(
	struct shash_instance *inst)
{
	return container_of(&inst->alg.base, struct crypto_instance, alg);
}

static inline struct shash_instance *shash_instance(
	struct crypto_instance *inst)
{
	return container_of(__crypto_shash_alg(&inst->alg),
			    struct shash_instance, alg);
}

static inline void *shash_instance_ctx(struct shash_instance *inst)
{
	return crypto_instance_ctx(shash_crypto_instance(inst));
}

static inline struct shash_instance *shash_alloc_instance(
	const char *name, struct crypto_alg *alg)
{
	return crypto_alloc_instance2(name, alg,
				      sizeof(struct shash_alg) - sizeof(*alg));
}

static inline struct crypto_shash *crypto_spawn_shash(
	struct crypto_shash_spawn *spawn)
{
	return crypto_spawn_tfm2(&spawn->base);
}

static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
{
	return crypto_tfm_ctx_aligned(&tfm->base);
}

static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
{
	return container_of(tfm, struct crypto_shash, base);
}

#endif	/* _CRYPTO_INTERNAL_HASH_H */
Commit	Line	Data
20036252 HX	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>
18e33e6d	17	#include <crypto/hash.h>
20036252 HX	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
01c2dece HX	37	struct ahash_instance {
	38	struct ahash_alg alg;
	39	};
	40
2e4fddd8 HX	41	struct shash_instance {
	42	struct shash_alg alg;
	43	};
	44
01c2dece HX	45	struct crypto_ahash_spawn {
	46	struct crypto_spawn base;
	47	};
	48
94296999 HX	49	struct crypto_shash_spawn {
	50	struct crypto_spawn base;
	51	};
	52
18e33e6d HX	53	extern const struct crypto_type crypto_ahash_type;
18e33e6d HX	54
20036252 HX	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);
75ecb231 HX	58	int crypto_ahash_walk_first(struct ahash_request *req,
75ecb231 HX	59	struct crypto_hash_walk *walk);
20036252	60
75ecb231 HX	61	static inline int crypto_ahash_walk_done(struct crypto_hash_walk *walk,
	62	int err)
	63	{
	64	return crypto_hash_walk_done(walk, err);
	65	}
	66
66f6ce5e HX	67	static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
	68	{
	69	return !(walk->entrylen \| walk->total);
	70	}
	71
75ecb231 HX	72	static inline int crypto_ahash_walk_last(struct crypto_hash_walk *walk)
	73	{
	74	return crypto_hash_walk_last(walk);
	75	}
	76
88056ec3 HX	77	int crypto_register_ahash(struct ahash_alg *alg);
88056ec3 HX	78	int crypto_unregister_ahash(struct ahash_alg *alg);
6f7473c5 RV	79	int crypto_register_ahashes(struct ahash_alg *algs, int count);
6f7473c5 RV	80	void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
01c2dece HX	81	int ahash_register_instance(struct crypto_template *tmpl,
	82	struct ahash_instance *inst);
	83	void ahash_free_instance(struct crypto_instance *inst);
	84
	85	int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
	86	struct hash_alg_common *alg,
	87	struct crypto_instance *inst);
	88
52861c7c HX	89	static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
	90	{
	91	crypto_drop_spawn(&spawn->base);
	92	}
	93
01c2dece	94	struct hash_alg_common ahash_attr_alg(struct rtattr rta, u32 type, u32 mask);
88056ec3	95
7b5a080b HX	96	int crypto_register_shash(struct shash_alg *alg);
7b5a080b HX	97	int crypto_unregister_shash(struct shash_alg *alg);
50fc3e8d JK	98	int crypto_register_shashes(struct shash_alg *algs, int count);
50fc3e8d JK	99	int crypto_unregister_shashes(struct shash_alg *algs, int count);
619a6ebd HX	100	int shash_register_instance(struct crypto_template *tmpl,
619a6ebd HX	101	struct shash_instance *inst);
2e4fddd8 HX	102	void shash_free_instance(struct crypto_instance *inst);
2e4fddd8 HX	103
94296999 HX	104	int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
	105	struct shash_alg *alg,
	106	struct crypto_instance *inst);
	107
52861c7c HX	108	static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
	109	{
	110	crypto_drop_spawn(&spawn->base);
	111	}
	112
7d6f5640 HX	113	struct shash_alg shash_attr_alg(struct rtattr rta, u32 type, u32 mask);
7d6f5640 HX	114
7eddf95e	115	int shash_ahash_update(struct ahash_request req, struct shash_desc desc);
66f6ce5e	116	int shash_ahash_finup(struct ahash_request req, struct shash_desc desc);
7eddf95e	117	int shash_ahash_digest(struct ahash_request req, struct shash_desc desc);
1e65b81a	118
331bf739 MD	119	int ahash_mcryptd_update(struct ahash_request *desc);
	120	int ahash_mcryptd_final(struct ahash_request *desc);
	121	int ahash_mcryptd_finup(struct ahash_request *desc);
	122	int ahash_mcryptd_digest(struct ahash_request *desc);
7eddf95e	123
88056ec3 HX	124	int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
88056ec3 HX	125
18e33e6d HX	126	static inline void crypto_ahash_ctx(struct crypto_ahash tfm)
18e33e6d HX	127	{
88056ec3	128	return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
18e33e6d HX	129	}
18e33e6d HX	130
4dc10c01 HX	131	static inline struct ahash_alg __crypto_ahash_alg(struct crypto_alg alg)
	132	{
	133	return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
	134	halg);
	135	}
	136
fc00127f HX	137	static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
	138	unsigned int reqsize)
	139	{
88056ec3	140	tfm->reqsize = reqsize;
fc00127f HX	141	}
fc00127f HX	142
01c2dece HX	143	static inline struct crypto_instance *ahash_crypto_instance(
	144	struct ahash_instance *inst)
	145	{
	146	return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
	147	}
	148
	149	static inline struct ahash_instance *ahash_instance(
	150	struct crypto_instance *inst)
	151	{
	152	return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
	153	}
	154
	155	static inline void ahash_instance_ctx(struct ahash_instance inst)
	156	{
	157	return crypto_instance_ctx(ahash_crypto_instance(inst));
	158	}
	159
	160	static inline unsigned int ahash_instance_headroom(void)
	161	{
	162	return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
	163	}
	164
	165	static inline struct ahash_instance *ahash_alloc_instance(
	166	const char name, struct crypto_alg alg)
	167	{
	168	return crypto_alloc_instance2(name, alg, ahash_instance_headroom());
	169	}
	170
ef0579b6 HX	171	static inline void ahash_request_complete(struct ahash_request *req, int err)
	172	{
	173	req->base.complete(&req->base, err);
	174	}
	175
	176	static inline u32 ahash_request_flags(struct ahash_request *req)
	177	{
	178	return req->base.flags;
	179	}
	180
01c2dece HX	181	static inline struct crypto_ahash *crypto_spawn_ahash(
	182	struct crypto_ahash_spawn *spawn)
	183	{
	184	return crypto_spawn_tfm2(&spawn->base);
	185	}
	186
18e33e6d HX	187	static inline int ahash_enqueue_request(struct crypto_queue *queue,
	188	struct ahash_request *request)
	189	{
	190	return crypto_enqueue_request(queue, &request->base);
	191	}
	192
	193	static inline struct ahash_request *ahash_dequeue_request(
	194	struct crypto_queue *queue)
	195	{
	196	return ahash_request_cast(crypto_dequeue_request(queue));
	197	}
	198
18e33e6d HX	199	static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
	200	struct crypto_ahash *tfm)
	201	{
	202	return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
	203	}
	204
7b5a080b HX	205	static inline void crypto_shash_ctx(struct crypto_shash tfm)
	206	{
	207	return crypto_tfm_ctx(&tfm->base);
	208	}
	209
2e4fddd8 HX	210	static inline struct crypto_instance *shash_crypto_instance(
	211	struct shash_instance *inst)
	212	{
	213	return container_of(&inst->alg.base, struct crypto_instance, alg);
	214	}
	215
	216	static inline struct shash_instance *shash_instance(
	217	struct crypto_instance *inst)
	218	{
	219	return container_of(__crypto_shash_alg(&inst->alg),
	220	struct shash_instance, alg);
	221	}
	222
ef5d590c HX	223	static inline void shash_instance_ctx(struct shash_instance inst)
	224	{
	225	return crypto_instance_ctx(shash_crypto_instance(inst));
	226	}
	227
2e4fddd8 HX	228	static inline struct shash_instance *shash_alloc_instance(
	229	const char name, struct crypto_alg alg)
	230	{
	231	return crypto_alloc_instance2(name, alg,
	232	sizeof(struct shash_alg) - sizeof(*alg));
	233	}
	234
94296999 HX	235	static inline struct crypto_shash *crypto_spawn_shash(
	236	struct crypto_shash_spawn *spawn)
	237	{
	238	return crypto_spawn_tfm2(&spawn->base);
	239	}
	240
cde6263f HX	241	static inline void crypto_shash_ctx_aligned(struct crypto_shash tfm)
	242	{
	243	return crypto_tfm_ctx_aligned(&tfm->base);
	244	}
	245
0390e6ae HX	246	static inline struct crypto_shash __crypto_shash_cast(struct crypto_tfm tfm)
0390e6ae HX	247	{
113adefc	248	return container_of(tfm, struct crypto_shash, base);
0390e6ae HX	249	}
0390e6ae HX	250
20036252 HX	251	#endif /* _CRYPTO_INTERNAL_HASH_H */
20036252 HX	252