/*

 * Copyright (C) 2002-2014 Free Software Foundation, Inc.

 *

 * This file is part of LIBTASN1.

 *

 * The LIBTASN1 library is free software; you can redistribute it

 * and/or modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA

 */

/*****************************************************/

/* File: structure.c                                 */

/* Description: Functions to create and delete an    */

/*  ASN1 tree.                                       */

/*****************************************************/

#include <int.h>

#include <structure.h>

#include "parser_aux.h"

#include <gstr.h>

extern char _asn1_identifierMissing[];

/******************************************************/

/* Function : _asn1_add_single_node                     */

/* Description: creates a new NODE_ASN element.       */

/* Parameters:                                        */

/*   type: type of the new element (see ASN1_ETYPE_         */

/*         and CONST_ constants).                     */

/* Return: pointer to the new element.                */

/******************************************************/

asn1_node

_asn1_add_single_node (unsigned int type)

{

  asn1_node punt;

  punt = calloc (1, sizeof (struct asn1_node_st));

  if (punt == NULL)

    return NULL;

  punt->type = type;

  return punt;

}

/******************************************************************/

/* Function : _asn1_find_left                                     */

/* Description: returns the NODE_ASN element with RIGHT field that*/

/*              points the element NODE.                          */

/* Parameters:                                                    */

/*   node: NODE_ASN element pointer.                              */

/* Return: NULL if not found.                                     */

/******************************************************************/

asn1_node

_asn1_find_left (asn1_node_const node)

{

  if ((node == NULL) || (node->left == NULL) || (node->left->down == node))

    return NULL;

  return node->left;

}

int

_asn1_create_static_structure (asn1_node_const pointer, char *output_file_name,

			       char *vector_name)

{

  FILE *file;

  asn1_node_const p;

  unsigned long t;

  file = fopen (output_file_name, "w");

  if (file == NULL)

    return ASN1_FILE_NOT_FOUND;

  fprintf (file, "#if HAVE_CONFIG_H\n");

  fprintf (file, "# include \"config.h\"\n");

  fprintf (file, "#endif\n\n");

  fprintf (file, "#include <libtasn1.h>\n\n");

  fprintf (file, "const asn1_static_node %s[] = {\n", vector_name);

  p = pointer;

  while (p)

    {

      fprintf (file, "  { ");

      if (p->name[0] != 0)

	fprintf (file, "\"%s\", ", p->name);

      else

	fprintf (file, "NULL, ");

      t = p->type;

      if (p->down)

	t |= CONST_DOWN;

      if (p->right)

	t |= CONST_RIGHT;

      fprintf (file, "%lu, ", t);

      if (p->value)

	fprintf (file, "\"%s\"},\n", p->value);

      else

	fprintf (file, "NULL },\n");

      if (p->down)

	{

	  p = p->down;

	}

      else if (p->right)

	{

	  p = p->right;

	}

      else

	{

	  while (1)

	    {

	      p = _asn1_find_up (p);

	      if (p == pointer)

		{

		  p = NULL;

		  break;

		}

	      if (p->right)

		{

		  p = p->right;

		  break;

		}

	    }

	}

    }

  fprintf (file, "  { NULL, 0, NULL }\n};\n");

  fclose (file);

  return ASN1_SUCCESS;

}

/**

 * asn1_array2tree:

 * @array: specify the array that contains ASN.1 declarations

 * @definitions: return the pointer to the structure created by

 *   *ARRAY ASN.1 declarations

 * @errorDescription: return the error description.

 *

 * Creates the structures needed to manage the ASN.1 definitions.

 * @array is a vector created by asn1_parser2array().

 *

 * Returns: %ASN1_SUCCESS if structure was created correctly,

 *   %ASN1_ELEMENT_NOT_EMPTY if *@definitions not NULL,

 *   %ASN1_IDENTIFIER_NOT_FOUND if in the file there is an identifier

 *   that is not defined (see @errorDescription for more information),

 *   %ASN1_ARRAY_ERROR if the array pointed by @array is wrong.

 **/

int

asn1_array2tree (const asn1_static_node * array, asn1_node * definitions,

		 char *errorDescription)

{

  asn1_node p, p_last = NULL;

  unsigned long k;

  int move;

  int result;

  unsigned int type;

  list_type *e_list = NULL;

  if (errorDescription)

    errorDescription[0] = 0;

  if (*definitions != NULL)

    return ASN1_ELEMENT_NOT_EMPTY;

  move = UP;

  for (k = 0; array[k].value || array[k].type || array[k].name; k++)

    {

      type = convert_old_type (array[k].type);

      p = _asn1_add_static_node (&e_list, type & (~CONST_DOWN));

      if (array[k].name)

	_asn1_set_name (p, array[k].name);

      if (array[k].value)

	_asn1_set_value (p, array[k].value, strlen (array[k].value) + 1);

      if (*definitions == NULL)

	*definitions = p;

      if (move == DOWN)

	{

	  if (p_last && p_last->down)

	      _asn1_delete_structure (e_list, &p_last->down, 0);

	  _asn1_set_down (p_last, p);

	}

      else if (move == RIGHT)

        {

	  if (p_last && p_last->right)

	      _asn1_delete_structure (e_list, &p_last->right, 0);

	  _asn1_set_right (p_last, p);

        }

      p_last = p;

      if (type & CONST_DOWN)

	move = DOWN;

      else if (type & CONST_RIGHT)

	move = RIGHT;

      else

	{

	  while (p_last != *definitions)

	    {

	      p_last = _asn1_find_up (p_last);

	      if (p_last == NULL)

		break;

	      if (p_last->type & CONST_RIGHT)

		{

		  p_last->type &= ~CONST_RIGHT;

		  move = RIGHT;

		  break;

		}

	    }			/* while */

	}

    }				/* while */

  if (p_last == *definitions)

    {

      result = _asn1_check_identifier (*definitions);

      if (result == ASN1_SUCCESS)

	{

	  _asn1_change_integer_value (*definitions);

	  result = _asn1_expand_object_id (&e_list, *definitions);

	}

    }

  else

    {

      result = ASN1_ARRAY_ERROR;

    }

  if (errorDescription != NULL)

    {

      if (result == ASN1_IDENTIFIER_NOT_FOUND)

	{

	  Estrcpy (errorDescription, ":: identifier '");

	  Estrcat (errorDescription, _asn1_identifierMissing);

	  Estrcat (errorDescription, "' not found");

	}

      else

	errorDescription[0] = 0;

    }

  if (result != ASN1_SUCCESS)

    {

      _asn1_delete_list_and_nodes (e_list);

      *definitions = NULL;

    }

  else

    _asn1_delete_list (e_list);

  return result;

}

/**

 * asn1_delete_structure:

 * @structure: pointer to the structure that you want to delete.

 *

 * Deletes the structure *@structure.  At the end, *@structure is set

 * to NULL.

 *

 * Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if

 *   *@structure was NULL.

 **/

int

asn1_delete_structure (asn1_node * structure)

{

  return _asn1_delete_structure (NULL, structure, 0);

}

/**

 * asn1_delete_structure2:

 * @structure: pointer to the structure that you want to delete.

 * @flags: additional flags (see %ASN1_DELETE_FLAG)

 *

 * Deletes the structure *@structure.  At the end, *@structure is set

 * to NULL.

 *

 * Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if

 *   *@structure was NULL.

 **/

int

asn1_delete_structure2 (asn1_node * structure, unsigned int flags)

{

  return _asn1_delete_structure (NULL, structure, flags);

}

int

_asn1_delete_structure (list_type *e_list, asn1_node * structure, unsigned int flags)

{

  asn1_node p, p2, p3;

  if (*structure == NULL)

    return ASN1_ELEMENT_NOT_FOUND;

  p = *structure;

  while (p)

    {

      if (p->down)

	{

	  p = p->down;

	}

      else

	{			/* no down */

	  p2 = p->right;

	  if (p != *structure)

	    {

	      p3 = _asn1_find_up (p);

	      _asn1_set_down (p3, p2);

	      if (e_list)

		_asn1_delete_node_from_list (e_list, p);

	      _asn1_remove_node (p, flags);

	      p = p3;

	    }

	  else

	    {			/* p==root */

	      p3 = _asn1_find_left (p);

	      if (!p3)

		{

		  p3 = _asn1_find_up (p);

		  if (p3)

		    _asn1_set_down (p3, p2);

		  else

		    {

		      if (p->right)

			p->right->left = NULL;

		    }

		}

	      else

		_asn1_set_right (p3, p2);

	      if (e_list)

		_asn1_delete_node_from_list (e_list, p);

	      _asn1_remove_node (p, flags);

	      p = NULL;

	    }

	}

    }

  *structure = NULL;

  return ASN1_SUCCESS;

}

/**

 * asn1_delete_element:

 * @structure: pointer to the structure that contains the element you

 *   want to delete.

 * @element_name: element's name you want to delete.

 *

 * Deletes the element named *@element_name inside *@structure.

 *

 * Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if

 *   the @element_name was not found.

 **/

int

asn1_delete_element (asn1_node structure, const char *element_name)

{

  asn1_node p2, p3, source_node;

  source_node = asn1_find_node (structure, element_name);

  if (source_node == NULL)

    return ASN1_ELEMENT_NOT_FOUND;

  p2 = source_node->right;

  p3 = _asn1_find_left (source_node);

  if (!p3)

    {

      p3 = _asn1_find_up (source_node);

      if (p3)

	_asn1_set_down (p3, p2);

      else if (source_node->right)

	source_node->right->left = NULL;

    }

  else

    _asn1_set_right (p3, p2);

  return asn1_delete_structure (&source_node);

}

#ifndef __clang_analyzer__

asn1_node

_asn1_copy_structure3 (asn1_node_const source_node)

{

  asn1_node_const p_s;

  asn1_node dest_node, p_d, p_d_prev;

  int move;

  if (source_node == NULL)

    return NULL;

  dest_node = _asn1_add_single_node (source_node->type);

  p_s = source_node;

  p_d = dest_node;

  move = DOWN;

  do

    {

      if (move != UP)

	{

	  if (p_s->name[0] != 0)

	    _asn1_cpy_name (p_d, p_s);

	  if (p_s->value)

	    _asn1_set_value (p_d, p_s->value, p_s->value_len);

	  if (p_s->down)

	    {

	      p_s = p_s->down;

	      p_d_prev = p_d;

	      p_d = _asn1_add_single_node (p_s->type);

	      _asn1_set_down (p_d_prev, p_d);

	      continue;

	    }

	  p_d->start = p_s->start;

	  p_d->end = p_s->end;

	}

      if (p_s == source_node)

	break;

      if (p_s->right)

	{

	  move = RIGHT;

	  p_s = p_s->right;

	  p_d_prev = p_d;

	  p_d = _asn1_add_single_node (p_s->type);

	  _asn1_set_right (p_d_prev, p_d);

	}

      else

	{

	  move = UP;

	  p_s = _asn1_find_up (p_s);

	  p_d = _asn1_find_up (p_d);

	}

    }

  while (p_s != source_node);

  return dest_node;

}

#else

/* Non-production code */

asn1_node

_asn1_copy_structure3 (asn1_node_const source_node)

{

  return NULL;

}

#endif /* __clang_analyzer__ */

static asn1_node

_asn1_copy_structure2 (asn1_node_const root, const char *source_name)

{

  asn1_node source_node;

  source_node = asn1_find_node (root, source_name);

  return _asn1_copy_structure3 (source_node);

}

static int

_asn1_type_choice_config (asn1_node node)

{

  asn1_node p, p2, p3, p4;

  int move, tlen;

  if (node == NULL)

    return ASN1_ELEMENT_NOT_FOUND;

  p = node;

  move = DOWN;

  while (!((p == node) && (move == UP)))

    {

      if (move != UP)

	{

	  if ((type_field (p->type) == ASN1_ETYPE_CHOICE)

	      && (p->type & CONST_TAG))

	    {

	      p2 = p->down;

	      while (p2)

		{

		  if (type_field (p2->type) != ASN1_ETYPE_TAG)

		    {

		      p2->type |= CONST_TAG;

		      p3 = _asn1_find_left (p2);

		      while (p3)

			{

			  if (type_field (p3->type) == ASN1_ETYPE_TAG)

			    {

			      p4 = _asn1_add_single_node (p3->type);

			      tlen = _asn1_strlen (p3->value);

			      if (tlen > 0)

				_asn1_set_value (p4, p3->value, tlen + 1);

			      _asn1_set_right (p4, p2->down);

			      _asn1_set_down (p2, p4);

			    }

			  p3 = _asn1_find_left (p3);

			}

		    }

		  p2 = p2->right;

		}

	      p->type &= ~(CONST_TAG);

	      p2 = p->down;

	      while (p2)

		{

		  p3 = p2->right;

		  if (type_field (p2->type) == ASN1_ETYPE_TAG)

		    asn1_delete_structure (&p2;;

		  p2 = p3;

		}

	    }

	  move = DOWN;

	}

      else

	move = RIGHT;

      if (move == DOWN)

	{

	  if (p->down)

	    p = p->down;

	  else

	    move = RIGHT;

	}

      if (p == node)

	{

	  move = UP;

	  continue;

	}

      if (move == RIGHT)

	{

	  if (p->right)

	    p = p->right;

	  else

	    move = UP;

	}

      if (move == UP)

	p = _asn1_find_up (p);

    }

  return ASN1_SUCCESS;

}

static int

_asn1_expand_identifier (asn1_node * node, asn1_node_const root)

{

  asn1_node p, p2, p3;

  char name2[ASN1_MAX_NAME_SIZE + 2];

  int move;

  if (node == NULL)

    return ASN1_ELEMENT_NOT_FOUND;

  p = *node;

  move = DOWN;

  while (!((p == *node) && (move == UP)))

    {

      if (move != UP)

	{

	  if (type_field (p->type) == ASN1_ETYPE_IDENTIFIER)

	    {

	      snprintf (name2, sizeof (name2), "%s.%s", root->name, p->value);

	      p2 = _asn1_copy_structure2 (root, name2);

	      if (p2 == NULL)

		{

		  return ASN1_IDENTIFIER_NOT_FOUND;

		}

	      _asn1_cpy_name (p2, p);

	      p2->right = p->right;

	      p2->left = p->left;

	      if (p->right)

		p->right->left = p2;

	      p3 = p->down;

	      if (p3)

		{

		  while (p3->right)

		    p3 = p3->right;

		  _asn1_set_right (p3, p2->down);

		  _asn1_set_down (p2, p->down);

		}

	      p3 = _asn1_find_left (p);

	      if (p3)

		_asn1_set_right (p3, p2);

	      else

		{

		  p3 = _asn1_find_up (p);

		  if (p3)

		    _asn1_set_down (p3, p2);

		  else

		    {

		      p2->left = NULL;

		    }

		}

	      if (p->type & CONST_SIZE)

		p2->type |= CONST_SIZE;

	      if (p->type & CONST_TAG)

		p2->type |= CONST_TAG;

	      if (p->type & CONST_OPTION)

		p2->type |= CONST_OPTION;

	      if (p->type & CONST_DEFAULT)

		p2->type |= CONST_DEFAULT;

	      if (p->type & CONST_SET)

		p2->type |= CONST_SET;

	      if (p->type & CONST_NOT_USED)

		p2->type |= CONST_NOT_USED;

	      if (p == *node)

		*node = p2;

	      _asn1_remove_node (p, 0);

	      p = p2;

	      move = DOWN;

	      continue;

	    }

	  move = DOWN;

	}

      else

	move = RIGHT;

      if (move == DOWN)

	{

	  if (p->down)

	    p = p->down;

	  else

	    move = RIGHT;

	}

      if (p == *node)

	{

	  move = UP;

	  continue;

	}

      if (move == RIGHT)

	{

	  if (p->right)

	    p = p->right;

	  else

	    move = UP;

	}

      if (move == UP)

	p = _asn1_find_up (p);

    }

  return ASN1_SUCCESS;

}

/**

 * asn1_create_element:

 * @definitions: pointer to the structure returned by "parser_asn1" function

 * @source_name: the name of the type of the new structure (must be

 *   inside p_structure).

 * @element: pointer to the structure created.

 *

 * Creates a structure of type @source_name.  Example using

 *  "pkix.asn":

 *

 * rc = asn1_create_element(cert_def, "PKIX1.Certificate", certptr);

 *

 * Returns: %ASN1_SUCCESS if creation OK, %ASN1_ELEMENT_NOT_FOUND if

 *   @source_name is not known.

 **/

int

asn1_create_element (asn1_node_const definitions, const char *source_name,

		     asn1_node * element)

{

  asn1_node dest_node;

  int res;

  dest_node = _asn1_copy_structure2 (definitions, source_name);

  if (dest_node == NULL)

    return ASN1_ELEMENT_NOT_FOUND;

  _asn1_set_name (dest_node, "");

  res = _asn1_expand_identifier (&dest_node, definitions);

  _asn1_type_choice_config (dest_node);

  *element = dest_node;

  return res;

}

/**

 * asn1_print_structure:

 * @out: pointer to the output file (e.g. stdout).

 * @structure: pointer to the structure that you want to visit.

 * @name: an element of the structure

 * @mode: specify how much of the structure to print, can be

 *   %ASN1_PRINT_NAME, %ASN1_PRINT_NAME_TYPE,

 *   %ASN1_PRINT_NAME_TYPE_VALUE, or %ASN1_PRINT_ALL.

 *

 * Prints on the @out file descriptor the structure's tree starting

 * from the @name element inside the structure @structure.

 **/

void

asn1_print_structure (FILE * out, asn1_node_const structure, const char *name,

		      int mode)

{

  asn1_node_const p, root;

  int k, indent = 0, len, len2, len3;

  if (out == NULL)

    return;

  root = asn1_find_node (structure, name);

  if (root == NULL)

    return;

  p = root;

  while (p)

    {

      if (mode == ASN1_PRINT_ALL)

	{

	  for (k = 0; k < indent; k++)

	    fprintf (out, " ");

	  fprintf (out, "name:");

	  if (p->name[0] != 0)

	    fprintf (out, "%s  ", p->name);

	  else

	    fprintf (out, "NULL  ");

	}

      else

	{

	  switch (type_field (p->type))

	    {

	    case ASN1_ETYPE_CONSTANT:

	    case ASN1_ETYPE_TAG:

	    case ASN1_ETYPE_SIZE:

	      break;

	    default:

	      for (k = 0; k < indent; k++)

		fprintf (out, " ");

	      fprintf (out, "name:");

	      if (p->name[0] != 0)

		fprintf (out, "%s  ", p->name);

	      else

		fprintf (out, "NULL  ");

	    }

	}

      if (mode != ASN1_PRINT_NAME)

	{

	  unsigned type = type_field (p->type);

	  switch (type)

	    {

	    case ASN1_ETYPE_CONSTANT:

	      if (mode == ASN1_PRINT_ALL)

		fprintf (out, "type:CONST");

	      break;

	    case ASN1_ETYPE_TAG:

	      if (mode == ASN1_PRINT_ALL)

		fprintf (out, "type:TAG");

	      break;

	    case ASN1_ETYPE_SIZE:

	      if (mode == ASN1_PRINT_ALL)

		fprintf (out, "type:SIZE");

	      break;

	    case ASN1_ETYPE_DEFAULT:

	      fprintf (out, "type:DEFAULT");

	      break;

	    case ASN1_ETYPE_IDENTIFIER:

	      fprintf (out, "type:IDENTIFIER");

	      break;

	    case ASN1_ETYPE_ANY:

	      fprintf (out, "type:ANY");

	      break;

	    case ASN1_ETYPE_CHOICE:

	      fprintf (out, "type:CHOICE");

	      break;

	    case ASN1_ETYPE_DEFINITIONS:

	      fprintf (out, "type:DEFINITIONS");

	      break;

	    CASE_HANDLED_ETYPES:

	      fprintf (out, "%s", _asn1_tags[type].desc);

	      break;

	    default:

	      break;

	    }

	}

      if ((mode == ASN1_PRINT_NAME_TYPE_VALUE) || (mode == ASN1_PRINT_ALL))

	{

	  switch (type_field (p->type))

	    {

	    case ASN1_ETYPE_CONSTANT:

	      if (mode == ASN1_PRINT_ALL)

		if (p->value)

		  fprintf (out, "  value:%s", p->value);

	      break;

	    case ASN1_ETYPE_TAG:

	      if (mode == ASN1_PRINT_ALL)

		if (p->value)

		  fprintf (out, "  value:%s", p->value);

	      break;

	    case ASN1_ETYPE_SIZE:

	      if (mode == ASN1_PRINT_ALL)

		if (p->value)

		  fprintf (out, "  value:%s", p->value);

	      break;

	    case ASN1_ETYPE_DEFAULT:

	      if (p->value)

		fprintf (out, "  value:%s", p->value);

	      else if (p->type & CONST_TRUE)

		fprintf (out, "  value:TRUE");

	      else if (p->type & CONST_FALSE)

		fprintf (out, "  value:FALSE");

	      break;

	    case ASN1_ETYPE_IDENTIFIER:

	      if (p->value)

		fprintf (out, "  value:%s", p->value);

	      break;

	    case ASN1_ETYPE_INTEGER:

	      if (p->value)

		{

		  len2 = -1;

		  len = asn1_get_length_der (p->value, p->value_len, &len2);

		  fprintf (out, "  value:0x");

		  if (len > 0)

		    for (k = 0; k < len; k++)

		      fprintf (out, "%02x", (unsigned) (p->value)[k + len2]);

		}

	      break;

	    case ASN1_ETYPE_ENUMERATED:

	      if (p->value)

		{

		  len2 = -1;

		  len = asn1_get_length_der (p->value, p->value_len, &len2);

		  fprintf (out, "  value:0x");

		  if (len > 0)

		    for (k = 0; k < len; k++)

		      fprintf (out, "%02x", (unsigned) (p->value)[k + len2]);

		}

	      break;

	    case ASN1_ETYPE_BOOLEAN:

	      if (p->value)

		{

		  if (p->value[0] == 'T')

		    fprintf (out, "  value:TRUE");

		  else if (p->value[0] == 'F')

		    fprintf (out, "  value:FALSE");