1/*
  2 * Symmetric key ciphers.
  3 * 
  4 * Copyright (c) 2007 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_SKCIPHER_H
 14#define _CRYPTO_INTERNAL_SKCIPHER_H
 15
 16#include <crypto/algapi.h>
 17#include <crypto/skcipher.h>
 18#include <linux/types.h>
 19
 20struct rtattr;
 21
 22struct crypto_skcipher_spawn {
 23	struct crypto_spawn base;
 24};
 25
 26extern const struct crypto_type crypto_givcipher_type;
 27
 28static inline void crypto_set_skcipher_spawn(
 29	struct crypto_skcipher_spawn *spawn, struct crypto_instance *inst)
 30{
 31	crypto_set_spawn(&spawn->base, inst);
 32}
 33
 34int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
 35			 u32 type, u32 mask);
 36
 
 
 37static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
 38{
 39	crypto_drop_spawn(&spawn->base);
 40}
 41
 42static inline struct crypto_alg *crypto_skcipher_spawn_alg(
 43	struct crypto_skcipher_spawn *spawn)
 44{
 45	return spawn->base.alg;
 46}
 47
 48static inline struct crypto_ablkcipher *crypto_spawn_skcipher(
 49	struct crypto_skcipher_spawn *spawn)
 50{
 51	return __crypto_ablkcipher_cast(
 52		crypto_spawn_tfm(&spawn->base, crypto_skcipher_type(0),
 53				 crypto_skcipher_mask(0)));
 54}
 55
 56int skcipher_null_givencrypt(struct skcipher_givcrypt_request *req);
 57int skcipher_null_givdecrypt(struct skcipher_givcrypt_request *req);
 58const char *crypto_default_geniv(const struct crypto_alg *alg);
 59
 60struct crypto_instance *skcipher_geniv_alloc(struct crypto_template *tmpl,
 61					     struct rtattr **tb, u32 type,
 62					     u32 mask);
 63void skcipher_geniv_free(struct crypto_instance *inst);
 64int skcipher_geniv_init(struct crypto_tfm *tfm);
 65void skcipher_geniv_exit(struct crypto_tfm *tfm);
 66
 67static inline struct crypto_ablkcipher *skcipher_geniv_cipher(
 68	struct crypto_ablkcipher *geniv)
 69{
 70	return crypto_ablkcipher_crt(geniv)->base;
 71}
 72
 73static inline int skcipher_enqueue_givcrypt(
 74	struct crypto_queue *queue, struct skcipher_givcrypt_request *request)
 75{
 76	return ablkcipher_enqueue_request(queue, &request->creq);
 77}
 78
 79static inline struct skcipher_givcrypt_request *skcipher_dequeue_givcrypt(
 80	struct crypto_queue *queue)
 81{
 82	return __crypto_dequeue_request(
 83		queue, offsetof(struct skcipher_givcrypt_request, creq.base));
 84}
 85
 86static inline void *skcipher_givcrypt_reqctx(
 87	struct skcipher_givcrypt_request *req)
 88{
 89	return ablkcipher_request_ctx(&req->creq);
 90}
 91
 92static inline void ablkcipher_request_complete(struct ablkcipher_request *req,
 93					       int err)
 94{
 95	req->base.complete(&req->base, err);
 96}
 97
 98static inline void skcipher_givcrypt_complete(
 99	struct skcipher_givcrypt_request *req, int err)
100{
101	ablkcipher_request_complete(&req->creq, err);
102}
103
104static inline u32 ablkcipher_request_flags(struct ablkcipher_request *req)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
105{
106	return req->base.flags;
107}
108
109#endif	/* _CRYPTO_INTERNAL_SKCIPHER_H */
110

  1/*
  2 * Symmetric key ciphers.
  3 * 
  4 * Copyright (c) 2007 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_SKCIPHER_H
 14#define _CRYPTO_INTERNAL_SKCIPHER_H
 15
 16#include <crypto/algapi.h>
 17#include <crypto/skcipher.h>
 18#include <linux/types.h>
 19
 20struct rtattr;
 21
 22struct crypto_skcipher_spawn {
 23	struct crypto_spawn base;
 24};
 25
 26extern const struct crypto_type crypto_givcipher_type;
 27
 28static inline void crypto_set_skcipher_spawn(
 29	struct crypto_skcipher_spawn *spawn, struct crypto_instance *inst)
 30{
 31	crypto_set_spawn(&spawn->base, inst);
 32}
 33
 34int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
 35			 u32 type, u32 mask);
 36
 37struct crypto_alg *crypto_lookup_skcipher(const char *name, u32 type, u32 mask);
 38
 39static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
 40{
 41	crypto_drop_spawn(&spawn->base);
 42}
 43
 44static inline struct crypto_alg *crypto_skcipher_spawn_alg(
 45	struct crypto_skcipher_spawn *spawn)
 46{
 47	return spawn->base.alg;
 48}
 49
 50static inline struct crypto_ablkcipher *crypto_spawn_skcipher(
 51	struct crypto_skcipher_spawn *spawn)
 52{
 53	return __crypto_ablkcipher_cast(
 54		crypto_spawn_tfm(&spawn->base, crypto_skcipher_type(0),
 55				 crypto_skcipher_mask(0)));
 56}
 57
 58int skcipher_null_givencrypt(struct skcipher_givcrypt_request *req);
 59int skcipher_null_givdecrypt(struct skcipher_givcrypt_request *req);
 60const char *crypto_default_geniv(const struct crypto_alg *alg);
 61
 62struct crypto_instance *skcipher_geniv_alloc(struct crypto_template *tmpl,
 63					     struct rtattr **tb, u32 type,
 64					     u32 mask);
 65void skcipher_geniv_free(struct crypto_instance *inst);
 66int skcipher_geniv_init(struct crypto_tfm *tfm);
 67void skcipher_geniv_exit(struct crypto_tfm *tfm);
 68
 69static inline struct crypto_ablkcipher *skcipher_geniv_cipher(
 70	struct crypto_ablkcipher *geniv)
 71{
 72	return crypto_ablkcipher_crt(geniv)->base;
 73}
 74
 75static inline int skcipher_enqueue_givcrypt(
 76	struct crypto_queue *queue, struct skcipher_givcrypt_request *request)
 77{
 78	return ablkcipher_enqueue_request(queue, &request->creq);
 79}
 80
 81static inline struct skcipher_givcrypt_request *skcipher_dequeue_givcrypt(
 82	struct crypto_queue *queue)
 83{
 84	return skcipher_givcrypt_cast(crypto_dequeue_request(queue));
 
 85}
 86
 87static inline void *skcipher_givcrypt_reqctx(
 88	struct skcipher_givcrypt_request *req)
 89{
 90	return ablkcipher_request_ctx(&req->creq);
 91}
 92
 93static inline void ablkcipher_request_complete(struct ablkcipher_request *req,
 94					       int err)
 95{
 96	req->base.complete(&req->base, err);
 97}
 98
 99static inline void skcipher_givcrypt_complete(
100	struct skcipher_givcrypt_request *req, int err)
101{
102	ablkcipher_request_complete(&req->creq, err);
103}
104
105static inline u32 ablkcipher_request_flags(struct ablkcipher_request *req)
106{
107	return req->base.flags;
108}
109
110static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm)
111{
112	return crypto_tfm_ctx(&tfm->base);
113}
114
115static inline void *skcipher_request_ctx(struct skcipher_request *req)
116{
117	return req->__ctx;
118}
119
120static inline u32 skcipher_request_flags(struct skcipher_request *req)
121{
122	return req->base.flags;
123}
124
125#endif	/* _CRYPTO_INTERNAL_SKCIPHER_H */
126