[thirdparty/openssl.git] / crypto / asn1 / ameth_lib.c

/* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
 * project 2006.
 */
/* ====================================================================
 * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>
#include "cryptlib.h"
#include <openssl/asn1t.h>
#include <openssl/x509.h>
#include <openssl/ec.h>
#include "asn1_locl.h"

extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[];
extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[];
extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth;
extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth;

/* Keep this sorted in type order !! */
const EVP_PKEY_ASN1_METHOD *standard_methods[] = 
	{
	&rsa_asn1_meths[0],
	&rsa_asn1_meths[1],
	&dh_asn1_meth,
	&dsa_asn1_meths[0],
	&dsa_asn1_meths[1],
	&dsa_asn1_meths[2],
	&dsa_asn1_meths[3],
	&dsa_asn1_meths[4],
	&eckey_asn1_meth
	};

typedef int sk_cmp_fn_type(const char * const *a, const char * const *b);
static STACK *app_methods = NULL;


#ifdef TEST
void main()
	{
	int i;
	for (i = 0;
		i < sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
		i++)
		fprintf(stderr, "Number %d id=%d (%s)\n", i,
			standard_methods[i]->pkey_id,
			OBJ_nid2sn(standard_methods[i]->pkey_id));
	}
#endif

static int ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a,
                const EVP_PKEY_ASN1_METHOD * const *b)
	{
        return ((*a)->pkey_id - (*b)->pkey_id);
	}

int EVP_PKEY_asn1_get_count(void)
	{
	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	if (app_methods)
		num += sk_num(app_methods);
	return num;
	}

const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
	{
	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	if (idx < 0)
		return NULL; 
	if (idx < num)
		return standard_methods[idx];
	idx -= num;
	return (const EVP_PKEY_ASN1_METHOD *)sk_value(app_methods, idx);
	}

const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(int type)
	{
	EVP_PKEY_ASN1_METHOD tmp, *t = &tmp, **ret;
	tmp.pkey_id = type;
	if (app_methods)
		{
		int idx;
		idx = sk_find(app_methods, (char *)&t);
		if (idx > 0)
			return (EVP_PKEY_ASN1_METHOD *)
				sk_value(app_methods, idx);
		}
	ret = (EVP_PKEY_ASN1_METHOD **) OBJ_bsearch((char *)&t,
        		(char *)standard_methods,
			sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *),
        		sizeof(EVP_PKEY_ASN1_METHOD *),
			(int (*)(const void *, const void *))ameth_cmp);
	if (!ret || !*ret)
		return NULL;
	if ((*ret)->pkey_flags & ASN1_PKEY_ALIAS)
		return EVP_PKEY_asn1_find((*ret)->pkey_base_id);
	return *ret;
	}

const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(const char *str, int len)
	{
	int i;
	const EVP_PKEY_ASN1_METHOD *ameth;
	for (i = 0; i < EVP_PKEY_asn1_get_count(); i++)
		{
		ameth = EVP_PKEY_asn1_get0(i);
		if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
			continue;
		if ((strlen(ameth->pem_str) == len) && 
			!strncasecmp(ameth->pem_str, str, len))
			return ameth;
		}
	return NULL;
	}

int EVP_PKEY_asn1_add(const EVP_PKEY_ASN1_METHOD *ameth)
	{
	if (app_methods == NULL)
		{
		app_methods = sk_new((sk_cmp_fn_type *)ameth_cmp);
		if (!app_methods)
			return 0;
		}
	if (!sk_push(app_methods, (char *)ameth))
		return 0;
	sk_sort(app_methods);
	return 1;
	}

EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id,
					const char *pem_str, const char *info)
	{
	EVP_PKEY_ASN1_METHOD *ameth;
	ameth = OPENSSL_malloc(sizeof(EVP_PKEY_ASN1_METHOD));
	if (!ameth)
		return NULL;

	ameth->pkey_id = id;
	ameth->pkey_base_id = id;
	ameth->pkey_flags = ASN1_PKEY_DYNAMIC;

	if (info)
		{
		ameth->info = BUF_strdup(info);
		if (!ameth->info)
			goto err;
		}

	if (pem_str)
		{
		ameth->pem_str = BUF_strdup(pem_str);
		if (!ameth->pem_str)
			goto err;
		}
	
	ameth->pub_decode = 0;
	ameth->pub_encode = 0;
	ameth->pub_cmp = 0;
	ameth->pub_print = 0;


	ameth->priv_decode = 0;
	ameth->priv_encode = 0;
	ameth->priv_print = 0;
	

	ameth->pkey_size = 0;
	ameth->pkey_bits = 0;

	ameth->param_decode = 0;
	ameth->param_encode = 0;
	ameth->param_missing = 0;
	ameth->param_copy = 0;
	ameth->param_cmp = 0;
	ameth->param_print = 0;


	ameth->pkey_free = 0;
	ameth->pkey_ctrl = 0;

	return ameth;

	err:

	EVP_PKEY_asn1_free(ameth);
	return NULL;

	}

void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
	{
	if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC))
		{
		if (ameth->pem_str)
			OPENSSL_free(ameth->pem_str);
		if (ameth->info)
			OPENSSL_free(ameth->info);
		OPENSSL_free(ameth);
		}
	}

void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
		int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub),
		int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk),
		int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
		int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent,
							ASN1_PCTX *pctx),
		int (*pkey_size)(const EVP_PKEY *pk),
		int (*pkey_bits)(const EVP_PKEY *pk))
	{
	ameth->pub_decode = pub_decode;
	ameth->pub_encode = pub_encode;
	ameth->pub_cmp = pub_cmp;
	ameth->pub_print = pub_print;
	ameth->pkey_size = pkey_size;
	ameth->pkey_bits = pkey_bits;
	}

void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
		int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf),
		int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk),
		int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent,
							ASN1_PCTX *pctx))
	{
	ameth->priv_decode = priv_decode;
	ameth->priv_encode = priv_encode;
	ameth->priv_print = priv_print;
	}

void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
		int (*param_decode)(const EVP_PKEY *pk, X509_PUBKEY *pub),
		int (*param_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk),
		int (*param_missing)(const EVP_PKEY *pk),
		int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from),
		int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
		int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent,
							ASN1_PCTX *pctx))
	{
	ameth->param_decode = param_decode;
	ameth->param_encode = param_encode;
	ameth->param_missing = param_missing;
	ameth->param_copy = param_copy;
	ameth->param_cmp = param_cmp;
	ameth->param_print = param_print;
	}

void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
		void (*pkey_free)(EVP_PKEY *pkey))
	{
	ameth->pkey_free = pkey_free;
	}

void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
		void (*pkey_ctrl)(EVP_PKEY *pkey, int op,
							long arg1, void *arg2))
	{
	ameth->pkey_ctrl = pkey_ctrl;
	}
Commit	Line	Data
448be743 DSH	1	/* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
	2	* project 2006.
	3	*/
	4	/* ====================================================================
	5	* Copyright (c) 2006 The OpenSSL Project. All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	*
	14	* 2. Redistributions in binary form must reproduce the above copyright
	15	* notice, this list of conditions and the following disclaimer in
	16	* the documentation and/or other materials provided with the
	17	* distribution.
	18	*
	19	* 3. All advertising materials mentioning features or use of this
	20	* software must display the following acknowledgment:
	21	* "This product includes software developed by the OpenSSL Project
	22	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	23	*
	24	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	25	* endorse or promote products derived from this software without
	26	* prior written permission. For written permission, please contact
	27	* licensing@OpenSSL.org.
	28	*
	29	* 5. Products derived from this software may not be called "OpenSSL"
	30	* nor may "OpenSSL" appear in their names without prior written
	31	* permission of the OpenSSL Project.
	32	*
	33	* 6. Redistributions of any form whatsoever must retain the following
	34	* acknowledgment:
	35	* "This product includes software developed by the OpenSSL Project
	36	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	37	*
	38	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	39	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	40	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	41	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	42	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	43	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	44	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	45	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	46	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	47	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	48	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	49	* OF THE POSSIBILITY OF SUCH DAMAGE.
	50	* ====================================================================
	51	*
	52	* This product includes cryptographic software written by Eric Young
	53	* (eay@cryptsoft.com). This product includes software written by Tim
	54	* Hudson (tjh@cryptsoft.com).
	55	*
	56	*/
	57
	58	#include <stdio.h>
	59	#include "cryptlib.h"
	60	#include <openssl/asn1t.h>
	61	#include <openssl/x509.h>
	62	#include <openssl/ec.h>
	63	#include "asn1_locl.h"
	64
65	extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[];
66	extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[];
6f81892e	67	extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth;
448be743 DSH	68	extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth;
	69
	70	/* Keep this sorted in type order !! */
	71	const EVP_PKEY_ASN1_METHOD *standard_methods[] =
	72	{
	73	&rsa_asn1_meths[0],
	74	&rsa_asn1_meths[1],
6f81892e	75	&dh_asn1_meth,
448be743 DSH	76	&dsa_asn1_meths[0],
	77	&dsa_asn1_meths[1],
	78	&dsa_asn1_meths[2],
	79	&dsa_asn1_meths[3],
	80	&dsa_asn1_meths[4],
	81	&eckey_asn1_meth
	82	};
	83
18e377b4 DSH	84	typedef int sk_cmp_fn_type(const char * const a, const char const *b);
	85	static STACK *app_methods = NULL;
	86
	87
	88
448be743 DSH	89	#ifdef TEST
	90	void main()
	91	{
	92	int i;
	93	for (i = 0;
	94	i < sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	95	i++)
6f81892e DSH	96	fprintf(stderr, "Number %d id=%d (%s)\n", i,
	97	standard_methods[i]->pkey_id,
	98	OBJ_nid2sn(standard_methods[i]->pkey_id));
448be743 DSH	99	}
	100	#endif
	101
	102	static int ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a,
	103	const EVP_PKEY_ASN1_METHOD * const *b)
	104	{
	105	return ((a)->pkey_id - (b)->pkey_id);
	106	}
	107
e4263314 DSH	108	int EVP_PKEY_asn1_get_count(void)
	109	{
	110	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	111	if (app_methods)
	112	num += sk_num(app_methods);
	113	return num;
	114	}
	115
	116	const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
	117	{
	118	int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
	119	if (idx < 0)
	120	return NULL;
	121	if (idx < num)
	122	return standard_methods[idx];
	123	idx -= num;
	124	return (const EVP_PKEY_ASN1_METHOD *)sk_value(app_methods, idx);
	125	}
	126
18e377b4	127	const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(int type)
448be743 DSH	128	{
	129	EVP_PKEY_ASN1_METHOD tmp, t = &tmp, *ret;
	130	tmp.pkey_id = type;
18e377b4 DSH	131	if (app_methods)
	132	{
	133	int idx;
	134	idx = sk_find(app_methods, (char *)&t);
	135	if (idx > 0)
	136	return (EVP_PKEY_ASN1_METHOD *)
	137	sk_value(app_methods, idx);
	138	}
448be743 DSH	139	ret = (EVP_PKEY_ASN1_METHOD *) OBJ_bsearch((char )&t,
	140	(char *)standard_methods,
	141	sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *),
	142	sizeof(EVP_PKEY_ASN1_METHOD *),
	143	(int ()(const void , const void *))ameth_cmp);
6f81892e DSH	144	if (!ret \|\| !*ret)
6f81892e DSH	145	return NULL;
448be743	146	if ((*ret)->pkey_flags & ASN1_PKEY_ALIAS)
18e377b4	147	return EVP_PKEY_asn1_find((*ret)->pkey_base_id);
448be743 DSH	148	return *ret;
	149	}
	150
e4263314 DSH	151	const EVP_PKEY_ASN1_METHOD EVP_PKEY_asn1_find_str(const char str, int len)
	152	{
	153	int i;
	154	const EVP_PKEY_ASN1_METHOD *ameth;
	155	for (i = 0; i < EVP_PKEY_asn1_get_count(); i++)
	156	{
	157	ameth = EVP_PKEY_asn1_get0(i);
	158	if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
	159	continue;
	160	if ((strlen(ameth->pem_str) == len) &&
	161	!strncasecmp(ameth->pem_str, str, len))
	162	return ameth;
	163	}
	164	return NULL;
	165	}
	166
18e377b4 DSH	167	int EVP_PKEY_asn1_add(const EVP_PKEY_ASN1_METHOD *ameth)
	168	{
	169	if (app_methods == NULL)
	170	{
	171	app_methods = sk_new((sk_cmp_fn_type *)ameth_cmp);
	172	if (!app_methods)
	173	return 0;
	174	}
	175	if (!sk_push(app_methods, (char *)ameth))
	176	return 0;
	177	sk_sort(app_methods);
	178	return 1;
	179	}
	180
d82e2718 DSH	181	EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id,
d82e2718 DSH	182	const char pem_str, const char info)
18e377b4 DSH	183	{
	184	EVP_PKEY_ASN1_METHOD *ameth;
	185	ameth = OPENSSL_malloc(sizeof(EVP_PKEY_ASN1_METHOD));
	186	if (!ameth)
	187	return NULL;
	188
	189	ameth->pkey_id = id;
	190	ameth->pkey_base_id = id;
	191	ameth->pkey_flags = ASN1_PKEY_DYNAMIC;
d82e2718 DSH	192
	193	if (info)
	194	{
	195	ameth->info = BUF_strdup(info);
	196	if (!ameth->info)
	197	goto err;
	198	}
	199
	200	if (pem_str)
	201	{
	202	ameth->pem_str = BUF_strdup(pem_str);
	203	if (!ameth->pem_str)
	204	goto err;
	205	}
18e377b4 DSH	206
	207	ameth->pub_decode = 0;
	208	ameth->pub_encode = 0;
	209	ameth->pub_cmp = 0;
	210	ameth->pub_print = 0;
	211
	212
	213	ameth->priv_decode = 0;
	214	ameth->priv_encode = 0;
	215	ameth->priv_print = 0;
	216
	217
	218	ameth->pkey_size = 0;
	219	ameth->pkey_bits = 0;
	220
	221	ameth->param_decode = 0;
	222	ameth->param_encode = 0;
	223	ameth->param_missing = 0;
	224	ameth->param_copy = 0;
	225	ameth->param_cmp = 0;
	226	ameth->param_print = 0;
	227
	228
	229	ameth->pkey_free = 0;
	230	ameth->pkey_ctrl = 0;
	231
	232	return ameth;
d82e2718 DSH	233
	234	err:
	235
	236	EVP_PKEY_asn1_free(ameth);
	237	return NULL;
	238
	239	}
	240
	241	void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
	242	{
	243	if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC))
	244	{
	245	if (ameth->pem_str)
	246	OPENSSL_free(ameth->pem_str);
	247	if (ameth->info)
	248	OPENSSL_free(ameth->info);
	249	OPENSSL_free(ameth);
	250	}
18e377b4 DSH	251	}
	252
	253	void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
	254	int (pub_decode)(EVP_PKEY pk, X509_PUBKEY *pub),
	255	int (pub_encode)(X509_PUBKEY pub, const EVP_PKEY *pk),
	256	int (pub_cmp)(const EVP_PKEY a, const EVP_PKEY *b),
	257	int (pub_print)(BIO out, const EVP_PKEY *pkey, int indent,
	258	ASN1_PCTX *pctx),
	259	int (pkey_size)(const EVP_PKEY pk),
	260	int (pkey_bits)(const EVP_PKEY pk))
	261	{
	262	ameth->pub_decode = pub_decode;
	263	ameth->pub_encode = pub_encode;
	264	ameth->pub_cmp = pub_cmp;
	265	ameth->pub_print = pub_print;
	266	ameth->pkey_size = pkey_size;
	267	ameth->pkey_bits = pkey_bits;
	268	}
	269
	270	void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
	271	int (priv_decode)(EVP_PKEY pk, PKCS8_PRIV_KEY_INFO *p8inf),
	272	int (priv_encode)(PKCS8_PRIV_KEY_INFO p8, const EVP_PKEY *pk),
	273	int (priv_print)(BIO out, const EVP_PKEY *pkey, int indent,
	274	ASN1_PCTX *pctx))
	275	{
	276	ameth->priv_decode = priv_decode;
	277	ameth->priv_encode = priv_encode;
	278	ameth->priv_print = priv_print;
	279	}
	280
	281	void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
	282	int (param_decode)(const EVP_PKEY pk, X509_PUBKEY *pub),
	283	int (param_encode)(X509_PUBKEY pub, const EVP_PKEY *pk),
	284	int (param_missing)(const EVP_PKEY pk),
	285	int (param_copy)(EVP_PKEY to, const EVP_PKEY *from),
	286	int (param_cmp)(const EVP_PKEY a, const EVP_PKEY *b),
	287	int (param_print)(BIO out, const EVP_PKEY *pkey, int indent,
	288	ASN1_PCTX *pctx))
	289	{
	290	ameth->param_decode = param_decode;
	291	ameth->param_encode = param_encode;
	292	ameth->param_missing = param_missing;
	293	ameth->param_copy = param_copy;
	294	ameth->param_cmp = param_cmp;
	295	ameth->param_print = param_print;
	296	}
	297
	298	void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
	299	void (pkey_free)(EVP_PKEY pkey))
	300	{
	301	ameth->pkey_free = pkey_free;
	302	}
	303
	304	void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
	305	void (pkey_ctrl)(EVP_PKEY pkey, int op,
	306	long arg1, void *arg2))
	307	{
	308	ameth->pkey_ctrl = pkey_ctrl;
	309	}