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

/*
 * Public Key Encryption
 *
 * Copyright (c) 2015, Intel Corporation
 * Authors: Tadeusz Struk <tadeusz.struk@intel.com>
 *
 * 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_AKCIPHER_INT_H
#define _CRYPTO_AKCIPHER_INT_H
#include <crypto/akcipher.h>
#include <crypto/algapi.h>

struct akcipher_instance {
	void (*free)(struct akcipher_instance *inst);
	union {
		struct {
			char head[offsetof(struct akcipher_alg, base)];
			struct crypto_instance base;
		} s;
		struct akcipher_alg alg;
	};
};

struct crypto_akcipher_spawn {
	struct crypto_spawn base;
};

/*
 * Transform internal helpers.
 */
static inline void *akcipher_request_ctx(struct akcipher_request *req)
{
	return req->__ctx;
}

static inline void *akcipher_tfm_ctx(struct crypto_akcipher *tfm)
{
	return tfm->base.__crt_ctx;
}

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

static inline const char *akcipher_alg_name(struct crypto_akcipher *tfm)
{
	return crypto_akcipher_tfm(tfm)->__crt_alg->cra_name;
}

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

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

static inline struct akcipher_instance *akcipher_alg_instance(
		struct crypto_akcipher *akcipher)
{
	return akcipher_instance(crypto_tfm_alg_instance(&akcipher->base));
}

static inline void *akcipher_instance_ctx(struct akcipher_instance *inst)
{
	return crypto_instance_ctx(akcipher_crypto_instance(inst));
}

static inline void crypto_set_akcipher_spawn(
		struct crypto_akcipher_spawn *spawn,
		struct crypto_instance *inst)
{
	crypto_set_spawn(&spawn->base, inst);
}

int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn, const char *name,
		u32 type, u32 mask);

static inline struct crypto_akcipher *crypto_spawn_akcipher(
		struct crypto_akcipher_spawn *spawn)
{
	return crypto_spawn_tfm2(&spawn->base);
}

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

static inline struct akcipher_alg *crypto_spawn_akcipher_alg(
		struct crypto_akcipher_spawn *spawn)
{
	return container_of(spawn->base.alg, struct akcipher_alg, base);
}

/**
 * crypto_register_akcipher() -- Register public key algorithm
 *
 * Function registers an implementation of a public key verify algorithm
 *
 * @alg:	algorithm definition
 *
 * Return: zero on success; error code in case of error
 */
int crypto_register_akcipher(struct akcipher_alg *alg);

/**
 * crypto_unregister_akcipher() -- Unregister public key algorithm
 *
 * Function unregisters an implementation of a public key verify algorithm
 *
 * @alg:	algorithm definition
 */
void crypto_unregister_akcipher(struct akcipher_alg *alg);

/**
 * akcipher_register_instance() -- Unregister public key template instance
 *
 * Function registers an implementation of an asymmetric key algorithm
 * created from a template
 *
 * @tmpl:	the template from which the algorithm was created
 * @inst:	the template instance
 */
int akcipher_register_instance(struct crypto_template *tmpl,
		struct akcipher_instance *inst);
#endif
Commit	Line	Data
3c339ab8 TS	1	/*
	2	* Public Key Encryption
	3	*
	4	* Copyright (c) 2015, Intel Corporation
	5	* Authors: Tadeusz Struk <tadeusz.struk@intel.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the Free
	9	* Software Foundation; either version 2 of the License, or (at your option)
	10	* any later version.
	11	*
	12	*/
	13	#ifndef _CRYPTO_AKCIPHER_INT_H
	14	#define _CRYPTO_AKCIPHER_INT_H
	15	#include <crypto/akcipher.h>
28a4618a AZ	16	#include <crypto/algapi.h>
	17
	18	struct akcipher_instance {
	19	void (free)(struct akcipher_instance inst);
	20	union {
	21	struct {
	22	char head[offsetof(struct akcipher_alg, base)];
	23	struct crypto_instance base;
	24	} s;
	25	struct akcipher_alg alg;
	26	};
	27	};
	28
	29	struct crypto_akcipher_spawn {
	30	struct crypto_spawn base;
	31	};
3c339ab8 TS	32
	33	/*
	34	* Transform internal helpers.
	35	*/
	36	static inline void akcipher_request_ctx(struct akcipher_request req)
	37	{
	38	return req->__ctx;
	39	}
	40
	41	static inline void akcipher_tfm_ctx(struct crypto_akcipher tfm)
	42	{
	43	return tfm->base.__crt_ctx;
	44	}
	45
	46	static inline void akcipher_request_complete(struct akcipher_request *req,
	47	int err)
	48	{
	49	req->base.complete(&req->base, err);
	50	}
	51
	52	static inline const char akcipher_alg_name(struct crypto_akcipher tfm)
	53	{
	54	return crypto_akcipher_tfm(tfm)->__crt_alg->cra_name;
	55	}
	56
28a4618a AZ	57	static inline struct crypto_instance *akcipher_crypto_instance(
	58	struct akcipher_instance *inst)
	59	{
	60	return container_of(&inst->alg.base, struct crypto_instance, alg);
	61	}
	62
	63	static inline struct akcipher_instance *akcipher_instance(
	64	struct crypto_instance *inst)
	65	{
	66	return container_of(&inst->alg, struct akcipher_instance, alg.base);
	67	}
	68
	69	static inline struct akcipher_instance *akcipher_alg_instance(
	70	struct crypto_akcipher *akcipher)
	71	{
	72	return akcipher_instance(crypto_tfm_alg_instance(&akcipher->base));
	73	}
	74
	75	static inline void akcipher_instance_ctx(struct akcipher_instance inst)
	76	{
	77	return crypto_instance_ctx(akcipher_crypto_instance(inst));
	78	}
	79
	80	static inline void crypto_set_akcipher_spawn(
	81	struct crypto_akcipher_spawn *spawn,
	82	struct crypto_instance *inst)
	83	{
	84	crypto_set_spawn(&spawn->base, inst);
	85	}
	86
	87	int crypto_grab_akcipher(struct crypto_akcipher_spawn spawn, const char name,
	88	u32 type, u32 mask);
	89
	90	static inline struct crypto_akcipher *crypto_spawn_akcipher(
	91	struct crypto_akcipher_spawn *spawn)
	92	{
	93	return crypto_spawn_tfm2(&spawn->base);
	94	}
	95
	96	static inline void crypto_drop_akcipher(struct crypto_akcipher_spawn *spawn)
	97	{
	98	crypto_drop_spawn(&spawn->base);
	99	}
	100
	101	static inline struct akcipher_alg *crypto_spawn_akcipher_alg(
	102	struct crypto_akcipher_spawn *spawn)
	103	{
	104	return container_of(spawn->base.alg, struct akcipher_alg, base);
	105	}
	106
3c339ab8 TS	107	/**
	108	* crypto_register_akcipher() -- Register public key algorithm
	109	*
	110	* Function registers an implementation of a public key verify algorithm
	111	*
	112	* @alg: algorithm definition
	113	*
	114	* Return: zero on success; error code in case of error
	115	*/
	116	int crypto_register_akcipher(struct akcipher_alg *alg);
	117
	118	/**
	119	* crypto_unregister_akcipher() -- Unregister public key algorithm
	120	*
	121	* Function unregisters an implementation of a public key verify algorithm
	122	*
	123	* @alg: algorithm definition
	124	*/
	125	void crypto_unregister_akcipher(struct akcipher_alg *alg);
28a4618a AZ	126
	127	/**
	128	* akcipher_register_instance() -- Unregister public key template instance
	129	*
	130	* Function registers an implementation of an asymmetric key algorithm
	131	* created from a template
	132	*
	133	* @tmpl: the template from which the algorithm was created
	134	* @inst: the template instance
	135	*/
	136	int akcipher_register_instance(struct crypto_template *tmpl,
	137	struct akcipher_instance *inst);
3c339ab8	138	#endif