/* tasn_new.c */

/* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL

 * project 2000.

 */

/* ====================================================================

 * Copyright (c) 2000-2004 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 <stddef.h>

#include <openssl/asn1.h>

#include <openssl/objects.h>

#include <openssl/err.h>

#include <openssl/asn1t.h>

#include <string.h>

static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,

								int combine);

static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);

static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);

void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);

EXPORT_C ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it)

	{

	ASN1_VALUE *ret = NULL;

	if (ASN1_item_ex_new(&ret, it) > 0)

		return ret;

	return NULL;

	}

/* Allocate an ASN1 structure */

EXPORT_C int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it)

	{

	return asn1_item_ex_combine_new(pval, it, 0);

	}

static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,

								int combine)

	{

	const ASN1_TEMPLATE *tt = NULL;

	const ASN1_COMPAT_FUNCS *cf;

	const ASN1_EXTERN_FUNCS *ef;

	const ASN1_AUX *aux = it->funcs;

	ASN1_aux_cb *asn1_cb;

	ASN1_VALUE **pseqval;

	int i;

	if (aux && aux->asn1_cb)

		asn1_cb = aux->asn1_cb;

	else

		asn1_cb = 0;

	if (!combine) *pval = NULL;

#ifdef CRYPTO_MDEBUG

	if (it->sname)

		CRYPTO_push_info(it->sname);

#endif

	switch(it->itype)

		{

		case ASN1_ITYPE_EXTERN:

		ef = it->funcs;

		if (ef && ef->asn1_ex_new)

			{

			if (!ef->asn1_ex_new(pval, it))

				goto memerr;

			}

		break;

		case ASN1_ITYPE_COMPAT:

		cf = it->funcs;

		if (cf && cf->asn1_new) {

			*pval = cf->asn1_new();

			if (!*pval)

				goto memerr;

		}

		break;

		case ASN1_ITYPE_PRIMITIVE:

		if (it->templates)

			{

			if (!ASN1_template_new(pval, it->templates))

				goto memerr;

			}

		else if (!ASN1_primitive_new(pval, it))

				goto memerr;

		break;

		case ASN1_ITYPE_MSTRING:

		if (!ASN1_primitive_new(pval, it))

				goto memerr;

		break;

		case ASN1_ITYPE_CHOICE:

		if (asn1_cb)

			{

			i = asn1_cb(ASN1_OP_NEW_PRE, pval, it);

			if (!i)

				goto auxerr;

			if (i==2)

				{

#ifdef CRYPTO_MDEBUG

				if (it->sname)

					CRYPTO_pop_info();

#endif

				return 1;

				}

			}

		if (!combine)

			{

			*pval = OPENSSL_malloc(it->size);

			if (!*pval)

				goto memerr;

			memset(*pval, 0, it->size);

			}

		asn1_set_choice_selector(pval, -1, it);

		if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it))

				goto auxerr;

		break;

		case ASN1_ITYPE_NDEF_SEQUENCE:

		case ASN1_ITYPE_SEQUENCE:

		if (asn1_cb)

			{

			i = asn1_cb(ASN1_OP_NEW_PRE, pval, it);

			if (!i)

				goto auxerr;

			if (i==2)

				{

#ifdef CRYPTO_MDEBUG

				if (it->sname)

					CRYPTO_pop_info();

#endif

				return 1;

				}

			}

		if (!combine)

			{

			*pval = OPENSSL_malloc(it->size);

			if (!*pval)

				goto memerr;

			memset(*pval, 0, it->size);

			asn1_do_lock(pval, 0, it);

			asn1_enc_init(pval, it);

			}

		for (i = 0, tt = it->templates; i < it->tcount; tt++, i++)

			{

			pseqval = asn1_get_field_ptr(pval, tt);

			if (!ASN1_template_new(pseqval, tt))

				goto memerr;

			}

		if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it))

				goto auxerr;

		break;

	}

#ifdef CRYPTO_MDEBUG

	if (it->sname) CRYPTO_pop_info();

#endif

	return 1;

	memerr:

	ASN1err(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW, ERR_R_MALLOC_FAILURE);

#ifdef CRYPTO_MDEBUG

	if (it->sname) CRYPTO_pop_info();

#endif

	return 0;

	auxerr:

	ASN1err(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW, ASN1_R_AUX_ERROR);

	ASN1_item_ex_free(pval, it);

#ifdef CRYPTO_MDEBUG

	if (it->sname) CRYPTO_pop_info();

#endif

	return 0;

	}

static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)

	{

	const ASN1_EXTERN_FUNCS *ef;

	switch(it->itype)

		{

		case ASN1_ITYPE_EXTERN:

		ef = it->funcs;

		if (ef && ef->asn1_ex_clear) 

			ef->asn1_ex_clear(pval, it);

		else *pval = NULL;

		break;

		case ASN1_ITYPE_PRIMITIVE:

		if (it->templates) 

			asn1_template_clear(pval, it->templates);

		else

			asn1_primitive_clear(pval, it);

		break;

		case ASN1_ITYPE_MSTRING:

		asn1_primitive_clear(pval, it);

		break;

		case ASN1_ITYPE_COMPAT:

		case ASN1_ITYPE_CHOICE:

		case ASN1_ITYPE_SEQUENCE:

		case ASN1_ITYPE_NDEF_SEQUENCE:

		*pval = NULL;

		break;

		}

	}

EXPORT_C int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)

	{

	const ASN1_ITEM *it = ASN1_ITEM_ptr(tt->item);

	int ret;

	if (tt->flags & ASN1_TFLG_OPTIONAL)

		{

		asn1_template_clear(pval, tt);

		return 1;

		}

	/* If ANY DEFINED BY nothing to do */

	if (tt->flags & ASN1_TFLG_ADB_MASK)

		{

		*pval = NULL;

		return 1;

		}

#ifdef CRYPTO_MDEBUG

	if (tt->field_name)

		CRYPTO_push_info(tt->field_name);

#endif

	/* If SET OF or SEQUENCE OF, its a STACK */

	if (tt->flags & ASN1_TFLG_SK_MASK)

		{

		STACK_OF(ASN1_VALUE) *skval;

		skval = sk_ASN1_VALUE_new_null();

		if (!skval)

			{

			ASN1err(ASN1_F_ASN1_TEMPLATE_NEW, ERR_R_MALLOC_FAILURE);

			ret = 0;

			goto done;

			}

		*pval = (ASN1_VALUE *)skval;

		ret = 1;

		goto done;

		}

	/* Otherwise pass it back to the item routine */

	ret = asn1_item_ex_combine_new(pval, it, tt->flags & ASN1_TFLG_COMBINE);

	done:

#ifdef CRYPTO_MDEBUG

	if (it->sname)

		CRYPTO_pop_info();

#endif

	return ret;

	}

static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)

	{

	/* If ADB or STACK just NULL the field */

	if (tt->flags & (ASN1_TFLG_ADB_MASK|ASN1_TFLG_SK_MASK)) 

		*pval = NULL;

	else

		asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item));

	}

/* NB: could probably combine most of the real XXX_new() behaviour and junk

 * all the old functions.

 */

EXPORT_C int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it)

	{

	ASN1_TYPE *typ;

	int utype;

	if (it && it->funcs)

		{

		const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;

		if (pf->prim_new)

			return pf->prim_new(pval, it);

		}

	if (!it || (it->itype == ASN1_ITYPE_MSTRING))

		utype = -1;

	else

		utype = it->utype;

	switch(utype)

		{

		case V_ASN1_OBJECT:

		*pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef);

		return 1;

		case V_ASN1_BOOLEAN:

		if (it)

			*(ASN1_BOOLEAN *)pval = it->size;

		else

			*(ASN1_BOOLEAN *)pval = -1;

		return 1;

		case V_ASN1_NULL:

		*pval = (ASN1_VALUE *)1;

		return 1;

		case V_ASN1_ANY:

		typ = OPENSSL_malloc(sizeof(ASN1_TYPE));

		if (!typ)

			return 0;

		typ->value.ptr = NULL;

		typ->type = -1;

		*pval = (ASN1_VALUE *)typ;

		break;

		default:

		*pval = (ASN1_VALUE *)ASN1_STRING_type_new(utype);

		break;

		}

	if (*pval)

		return 1;

	return 0;

	}

EXPORT_C void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)

	{

	int utype;

	if (it && it->funcs)

		{

		const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;

		if (pf->prim_clear)

			pf->prim_clear(pval, it);

		else 

			*pval = NULL;

		return;

		}

	if (!it || (it->itype == ASN1_ITYPE_MSTRING))

		utype = -1;

	else

		utype = it->utype;

	if (utype == V_ASN1_BOOLEAN)

		*(ASN1_BOOLEAN *)pval = it->size;

	else *pval = NULL;

	}