/* Return: */
/******************************************************/
static void
-_asn1_error_description_value_not_found (ASN1_TYPE node,
+_asn1_error_description_value_not_found (asn1_node node,
char *ErrorDescription)
{
/* ASN1_MEM_ERROR when DER isn't big enough */
/* ASN1_SUCCESS otherwise */
/******************************************************/
-static asn1_retCode
+static int
_asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
{
int len_len;
/* ASN1_MEM_ERROR when DER isn't big enough */
/* ASN1_SUCCESS otherwise */
/******************************************************/
-static asn1_retCode
+static int
_asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
{
int len_len, counter, k, first, max_len;
/* ASN1_MEM_ERROR if der vector isn't big enough, */
/* otherwise ASN1_SUCCESS. */
/******************************************************/
-static asn1_retCode
-_asn1_complete_explicit_tag (ASN1_TYPE node, unsigned char *der,
+static int
+_asn1_complete_explicit_tag (asn1_node node, unsigned char *der,
int *counter, int *max_len)
{
- ASN1_TYPE p;
+ asn1_node p;
int is_tag_implicit, len2, len3;
unsigned char temp[SIZEOF_UNSIGNED_INT];
/* ASN1_MEM_ERROR if der vector isn't big enough, */
/* otherwise ASN1_SUCCESS. */
/******************************************************/
-static asn1_retCode
-_asn1_insert_tag_der (ASN1_TYPE node, unsigned char *der, int *counter,
+static int
+_asn1_insert_tag_der (asn1_node node, unsigned char *der, int *counter,
int *max_len)
{
- ASN1_TYPE p;
+ asn1_node p;
int tag_len, is_tag_implicit;
unsigned char class, class_implicit = 0, temp[SIZEOF_UNSIGNED_INT * 3 + 1];
unsigned long tag_implicit = 0;
/* Return: */
/******************************************************/
static void
-_asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE node)
+_asn1_ordering_set (unsigned char *der, int der_len, asn1_node node)
{
struct vet
{
int counter, len, len2;
struct vet *first, *last, *p_vet, *p2_vet;
- ASN1_TYPE p;
+ asn1_node p;
unsigned char class, *temp;
unsigned long tag;
/* Return: */
/******************************************************/
static void
-_asn1_ordering_set_of (unsigned char *der, int der_len, ASN1_TYPE node)
+_asn1_ordering_set_of (unsigned char *der, int der_len, asn1_node node)
{
struct vet
{
int counter, len, len2, change;
struct vet *first, *last, *p_vet, *p2_vet;
- ASN1_TYPE p;
+ asn1_node p;
unsigned char *temp, class;
unsigned long k, max;
* vector isn't big enough and in this case @len will contain the
* length needed.
**/
-asn1_retCode
-asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
+int
+asn1_der_coding (asn1_node element, const char *name, void *ider, int *len,
char *ErrorDescription)
{
- ASN1_TYPE node, p, p2;
+ asn1_node node, p, p2;
unsigned char temp[SIZEOF_UNSIGNED_LONG_INT * 3 + 1];
int counter, counter_old, len2, len3, tlen, move, max_len, max_len_old;
- asn1_retCode err;
+ int err;
unsigned char *der = ider;
node = asn1_find_node (element, name);
#include "element.h"
#include <limits.h>
-static asn1_retCode
+static int
_asn1_get_indefinite_length_string (const unsigned char *der, int *len);
static void
-_asn1_error_description_tag_error (ASN1_TYPE node, char *ErrorDescription)
+_asn1_error_description_tag_error (asn1_node node, char *ErrorDescription)
{
Estrcpy (ErrorDescription, ":: tag error near element '");
}
static int
-_asn1_extract_tag_der (ASN1_TYPE node, const unsigned char *der, int der_len,
+_asn1_extract_tag_der (asn1_node node, const unsigned char *der, int der_len,
int *ret_len)
{
- ASN1_TYPE p;
+ asn1_node p;
int counter, len2, len3, is_tag_implicit;
unsigned long tag, tag_implicit = 0;
unsigned char class, class2, class_implicit = 0;
}
static int
-_asn1_delete_not_used (ASN1_TYPE node)
+_asn1_delete_not_used (asn1_node node)
{
- ASN1_TYPE p, p2;
+ asn1_node p, p2;
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
return ASN1_SUCCESS;
}
-static asn1_retCode
-_asn1_extract_der_octet (ASN1_TYPE node, const unsigned char *der,
+static int
+_asn1_extract_der_octet (asn1_node node, const unsigned char *der,
int der_len)
{
int len2, len3;
return ASN1_SUCCESS;
}
-static asn1_retCode
-_asn1_get_octet_string (const unsigned char *der, ASN1_TYPE node, int *len)
+static int
+_asn1_get_octet_string (const unsigned char *der, asn1_node node, int *len)
{
int len2, len3, counter, tot_len, indefinite;
}
-static asn1_retCode
+static int
_asn1_get_indefinite_length_string (const unsigned char *der, int *len)
{
int len2, len3, counter, indefinite;
* string. The structure must just be created with function
* asn1_create_element(). If an error occurs during the decoding
* procedure, the *@ELEMENT is deleted and set equal to
- * %ASN1_TYPE_EMPTY.
+ * %NULL.
*
* Returns: %ASN1_SUCCESS if DER encoding OK, %ASN1_ELEMENT_NOT_FOUND
- * if @ELEMENT is %ASN1_TYPE_EMPTY, and %ASN1_TAG_ERROR or
+ * if @ELEMENT is %NULL, and %ASN1_TAG_ERROR or
* %ASN1_DER_ERROR if the der encoding doesn't match the structure
* name (*@ELEMENT deleted).
**/
-asn1_retCode
-asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
+int
+asn1_der_decoding (asn1_node * element, const void *ider, int len,
char *errorDescription)
{
- ASN1_TYPE node, p, p2, p3;
+ asn1_node node, p, p2, p3;
char temp[128];
int counter, len2, len3, len4, move, ris, tlen;
unsigned char class;
node = *element;
- if (node == ASN1_TYPE_EMPTY)
+ if (errorDescription != NULL)
+ errorDescription[0] = 0;
+
+ if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
if (node->type & CONST_OPTION)
* asn1_create_element(). The DER vector must contain the encoding
* string of the whole @STRUCTURE. If an error occurs during the
* decoding procedure, the *@STRUCTURE is deleted and set equal to
- * %ASN1_TYPE_EMPTY.
+ * %NULL.
*
* Returns: %ASN1_SUCCESS if DER encoding OK, %ASN1_ELEMENT_NOT_FOUND
- * if ELEMENT is %ASN1_TYPE_EMPTY or @elementName == NULL, and
+ * if ELEMENT is %NULL or @elementName == NULL, and
* %ASN1_TAG_ERROR or %ASN1_DER_ERROR if the der encoding doesn't
* match the structure @structure (*ELEMENT deleted).
**/
-asn1_retCode
-asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
+int
+asn1_der_decoding_element (asn1_node * structure, const char *elementName,
const void *ider, int len, char *errorDescription)
{
- ASN1_TYPE node, p, p2, p3, nodeFound = ASN1_TYPE_EMPTY;
+ asn1_node node, p, p2, p3, nodeFound = NULL;
char temp[128], currentName[ASN1_MAX_NAME_SIZE * 10], *dot_p, *char_p;
int nameLen = ASN1_MAX_NAME_SIZE * 10 - 1, state;
int counter, len2, len3, len4, move, ris, tlen;
node = *structure;
- if (node == ASN1_TYPE_EMPTY)
+ if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
if (elementName == NULL)
* certificate.
*
* Returns: %ASN1_SUCCESS if DER encoding OK, %ASN1_ELEMENT_NOT_FOUND
- * if ELEMENT is %ASN1_TYPE EMPTY or @name_element is not a valid
+ * if ELEMENT is %asn1_node EMPTY or @name_element is not a valid
* element, %ASN1_TAG_ERROR or %ASN1_DER_ERROR if the der encoding
* doesn't match the structure ELEMENT.
**/
-asn1_retCode
-asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
+int
+asn1_der_decoding_startEnd (asn1_node element, const void *ider, int len,
const char *name_element, int *start, int *end)
{
- ASN1_TYPE node, node_to_find, p, p2, p3;
+ asn1_node node, node_to_find, p, p2, p3;
int counter, len2, len3, len4, move, ris;
unsigned char class;
unsigned long tag;
node = element;
- if (node == ASN1_TYPE_EMPTY)
+ if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
node_to_find = asn1_find_node (node, name_element);
* problem in OBJECT_ID -> TYPE association, or other error codes
* depending on DER decoding.
**/
-asn1_retCode
-asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
+int
+asn1_expand_any_defined_by (asn1_node definitions, asn1_node * element)
{
char definitionsName[ASN1_MAX_NAME_SIZE], name[2 * ASN1_MAX_NAME_SIZE + 1],
value[ASN1_MAX_NAME_SIZE];
- asn1_retCode retCode = ASN1_SUCCESS, result;
+ int retCode = ASN1_SUCCESS, result;
int len, len2, len3;
- ASN1_TYPE p, p2, p3, aux = ASN1_TYPE_EMPTY;
+ asn1_node p, p2, p3, aux = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- if ((definitions == ASN1_TYPE_EMPTY) || (*element == ASN1_TYPE_EMPTY))
+ if ((definitions == NULL) || (*element == NULL))
return ASN1_ELEMENT_NOT_FOUND;
strcpy (definitionsName, definitions->name);
if (result == ASN1_SUCCESS)
{
p = aux;
- aux = ASN1_TYPE_EMPTY;
+ aux = NULL;
break;
}
else
* %ASN1_VALUE_NOT_VALID if it wasn't possible to find the type to
* use for expansion, or other errors depending on DER decoding.
**/
-asn1_retCode
-asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
+int
+asn1_expand_octet_string (asn1_node definitions, asn1_node * element,
const char *octetName, const char *objectName)
{
char name[2 * ASN1_MAX_NAME_SIZE + 1], value[ASN1_MAX_NAME_SIZE];
- asn1_retCode retCode = ASN1_SUCCESS, result;
+ int retCode = ASN1_SUCCESS, result;
int len, len2, len3;
- ASN1_TYPE p2, aux = ASN1_TYPE_EMPTY;
- ASN1_TYPE octetNode = ASN1_TYPE_EMPTY, objectNode = ASN1_TYPE_EMPTY;
+ asn1_node p2, aux = NULL;
+ asn1_node octetNode = NULL, objectNode = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
- if ((definitions == ASN1_TYPE_EMPTY) || (*element == ASN1_TYPE_EMPTY))
+ if ((definitions == NULL) || (*element == NULL))
return ASN1_ELEMENT_NOT_FOUND;
octetNode = asn1_find_node (*element, octetName);
- if (octetNode == ASN1_TYPE_EMPTY)
+ if (octetNode == NULL)
return ASN1_ELEMENT_NOT_FOUND;
if (type_field (octetNode->type) != TYPE_OCTET_STRING)
return ASN1_ELEMENT_NOT_FOUND;
return ASN1_VALUE_NOT_FOUND;
objectNode = asn1_find_node (*element, objectName);
- if (objectNode == ASN1_TYPE_EMPTY)
+ if (objectNode == NULL)
return ASN1_ELEMENT_NOT_FOUND;
if (type_field (objectNode->type) != TYPE_OBJECT_ID)
result = asn1_delete_structure (&octetNode);
if (result == ASN1_SUCCESS)
{
- aux = ASN1_TYPE_EMPTY;
+ aux = NULL;
break;
}
else
#include "element.h"
void
-_asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size)
+_asn1_hierarchical_name (asn1_node node, char *name, int name_size)
{
- ASN1_TYPE p;
+ asn1_node p;
char tmp_name[64];
p = node;
/* len: number of significant byte of value_out. */
/* Return: ASN1_MEM_ERROR or ASN1_SUCCESS */
/******************************************************************/
-asn1_retCode
+int
_asn1_convert_integer (const unsigned char *value, unsigned char *value_out,
int value_out_size, int *len)
{
int
-_asn1_append_sequence_set (ASN1_TYPE node)
+_asn1_append_sequence_set (asn1_node node)
{
- ASN1_TYPE p, p2;
+ asn1_node p, p2;
char temp[10];
long n;
* %ASN1_ELEMENT_NOT_FOUND if @name is not a valid element, and
* %ASN1_VALUE_NOT_VALID if @ivalue has a wrong format.
**/
-asn1_retCode
-asn1_write_value (ASN1_TYPE node_root, const char *name,
+int
+asn1_write_value (asn1_node node_root, const char *name,
const void *ivalue, int len)
{
- ASN1_TYPE node, p, p2;
+ asn1_node node, p, p2;
unsigned char *temp, *value_temp = NULL, *default_temp = NULL;
int len2, k, k2, negative;
size_t i;
* to store the result, and in this case @len will contain the number of
* bytes needed.
**/
-asn1_retCode
-asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
+int
+asn1_read_value (asn1_node root, const char *name, void *ivalue, int *len)
{
- ASN1_TYPE node, p, p2;
+ asn1_node node, p, p2;
int len2, len3;
int value_size = *len;
unsigned char *value = ivalue;
* Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if
* @name is not a valid element.
**/
-asn1_retCode
-asn1_read_tag (ASN1_TYPE root, const char *name, int *tagValue,
+int
+asn1_read_tag (asn1_node root, const char *name, int *tagValue,
int *classValue)
{
- ASN1_TYPE node, p, pTag;
+ asn1_node node, p, pTag;
node = asn1_find_node (root, name);
if (node == NULL)
/**
* asn1_read_node_value:
* @node: pointer to a node.
- * @data: a point to a node_data_struct
+ * @data: a point to a asn1_data_node_st
*
- * Returns the value a data node inside a ASN1_TYPE structure.
+ * Returns the value a data node inside a asn1_node structure.
* The data returned should be handled as constant values.
*
* Returns: %ASN1_SUCCESS if the node exists.
**/
-asn1_retCode asn1_read_node_value (ASN1_TYPE node, ASN1_DATA_NODE* data)
+int asn1_read_node_value (asn1_node node, asn1_data_node_st* data)
{
data->name = node->name;
data->value = node->value;
#define _ELEMENT_H
-asn1_retCode _asn1_append_sequence_set (ASN1_TYPE node);
+int _asn1_append_sequence_set (asn1_node node);
-asn1_retCode _asn1_convert_integer (const unsigned char *value,
+int _asn1_convert_integer (const unsigned char *value,
unsigned char *value_out,
int value_out_size, int *len);
-void _asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size);
+void _asn1_hierarchical_name (asn1_node node, char *name, int name_size);
#endif
* Since: 1.6
**/
void
-asn1_perror (asn1_retCode error)
+asn1_perror (int error)
{
const char *str = asn1_strerror (error);
fprintf (stderr, "LIBTASN1 ERROR: %s\n", str ? str : "(null)");
* Since: 1.6
**/
const char *
-asn1_strerror (asn1_retCode error)
+asn1_strerror (int error)
{
const libtasn1_error_entry *p;
/* This structure is also in libtasn1.h, but then contains less
fields. You cannot make any modifications to these first fields
without breaking ABI. */
-struct node_asn_struct
+struct asn1_node_st
{
/* public fields: */
char name[ASN1_MAX_NAME_SIZE+1]; /* Node name */
unsigned int type; /* Node type */
unsigned char *value; /* Node value */
int value_len;
- ASN1_TYPE down; /* Pointer to the son node */
- ASN1_TYPE right; /* Pointer to the brother node */
- ASN1_TYPE left; /* Pointer to the next list element */
+ asn1_node down; /* Pointer to the son node */
+ asn1_node right; /* Pointer to the brother node */
+ asn1_node left; /* Pointer to the next list element */
/* private fields: */
unsigned char small_value[ASN1_SMALL_VALUE_SIZE]; /* For small values */
};
/****************************************/
/* Returns the first 8 bits. */
-/* Used with the field type of node_asn */
+/* Used with the field type of asn1_node_st */
/****************************************/
#define type_field(x) (x&0xFF)
-/* List of constants for field type of typedef node_asn */
+/* List of constants for field type of typedef asn1_node_st */
#define TYPE_CONSTANT ASN1_ETYPE_CONSTANT
#define TYPE_IDENTIFIER ASN1_ETYPE_IDENTIFIER
#define TYPE_INTEGER ASN1_ETYPE_INTEGER
/***********************************************************************/
-/* List of constants to better specify the type of typedef node_asn. */
+/* List of constants to better specify the type of typedef asn1_node_st. */
/***********************************************************************/
/* Used with TYPE_TAG */
#define CONST_UNIVERSAL (1<<8)
#define ASN1_VERSION "3.0"
- typedef int asn1_retCode; /* type returned by libtasn1 functions */
-
/*****************************************/
/* Errors returned by libtasn1 functions */
/*****************************************/
/* that represent an ASN.1 DEFINITION. */
/******************************************************/
- typedef struct node_asn_struct node_asn;
+ typedef struct asn1_node_st asn1_node_st;
- typedef node_asn *ASN1_TYPE;
+ typedef asn1_node_st *asn1_node;
/* maximum number of characters of a name */
/* inside a file with ASN1 definitons */
#define ASN1_MAX_NAME_SIZE 64
-#define ASN1_TYPE_EMPTY NULL
/*****************************************/
/* For the on-disk format of ASN.1 trees */
/*****************************************/
- struct static_struct_asn
+ struct asn1_static_node_st
{
const char *name; /* Node name */
unsigned int type; /* Node type */
const void *value; /* Node value */
};
- typedef struct static_struct_asn ASN1_ARRAY_TYPE;
+ typedef struct asn1_static_node_st asn1_static_node_t;
/* List of constants for field type of typedef node_asn */
#define ASN1_ETYPE_CONSTANT 1
#define ASN1_ETYPE_ENUMERATED 21
#define ASN1_ETYPE_GENERALSTRING 27
- struct node_data_struct
+ struct asn1_data_node_st
{
const char *name; /* Node name */
const void *value; /* Node value */
unsigned int value_len; /* Node value size */
unsigned int type; /* Node value type (ASN1_ETYPE_*) */
};
- typedef struct node_data_struct ASN1_DATA_NODE;
+ typedef struct asn1_data_node_st asn1_data_node_st;
/***********************************/
/* Fixed constants */
/* Functions definitions */
/***********************************/
- extern ASN1_API asn1_retCode
+ extern ASN1_API int
asn1_parser2tree (const char *file_name,
- ASN1_TYPE * definitions, char *errorDescription);
+ asn1_node * definitions, char *errorDescription);
- extern ASN1_API asn1_retCode
+ extern ASN1_API int
asn1_parser2array (const char *inputFileName,
const char *outputFileName,
const char *vectorName, char *errorDescription);
- extern ASN1_API asn1_retCode
- asn1_array2tree (const ASN1_ARRAY_TYPE * array,
- ASN1_TYPE * definitions, char *errorDescription);
+ extern ASN1_API int
+ asn1_array2tree (const asn1_static_node_t * array,
+ asn1_node * definitions, char *errorDescription);
extern ASN1_API void
- asn1_print_structure (FILE * out, ASN1_TYPE structure,
+ asn1_print_structure (FILE * out, asn1_node structure,
const char *name, int mode);
- extern ASN1_API asn1_retCode
- asn1_create_element (ASN1_TYPE definitions,
- const char *source_name, ASN1_TYPE * element);
+ extern ASN1_API int
+ asn1_create_element (asn1_node definitions,
+ const char *source_name, asn1_node * element);
- extern ASN1_API asn1_retCode asn1_delete_structure (ASN1_TYPE * structure);
+ extern ASN1_API int asn1_delete_structure (asn1_node * structure);
- extern ASN1_API asn1_retCode
- asn1_delete_element (ASN1_TYPE structure, const char *element_name);
+ extern ASN1_API int
+ asn1_delete_element (asn1_node structure, const char *element_name);
- extern ASN1_API asn1_retCode
- asn1_write_value (ASN1_TYPE node_root, const char *name,
+ extern ASN1_API int
+ asn1_write_value (asn1_node node_root, const char *name,
const void *ivalue, int len);
- extern ASN1_API asn1_retCode
- asn1_read_value (ASN1_TYPE root, const char *name,
+ extern ASN1_API int
+ asn1_read_value (asn1_node root, const char *name,
void *ivalue, int *len);
- extern ASN1_API asn1_retCode
- asn1_read_node_value (ASN1_TYPE node, ASN1_DATA_NODE* data);
+ extern ASN1_API int
+ asn1_read_node_value (asn1_node node, asn1_data_node_st* data);
- extern ASN1_API asn1_retCode
- asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num);
+ extern ASN1_API int
+ asn1_number_of_elements (asn1_node element, const char *name, int *num);
- extern ASN1_API asn1_retCode
- asn1_der_coding (ASN1_TYPE element, const char *name,
+ extern ASN1_API int
+ asn1_der_coding (asn1_node element, const char *name,
void *ider, int *len, char *ErrorDescription);
- extern ASN1_API asn1_retCode
- asn1_der_decoding (ASN1_TYPE * element, const void *ider,
+ extern ASN1_API int
+ asn1_der_decoding (asn1_node * element, const void *ider,
int len, char *errorDescription);
- extern ASN1_API asn1_retCode
- asn1_der_decoding_element (ASN1_TYPE * structure,
+ extern ASN1_API int
+ asn1_der_decoding_element (asn1_node * structure,
const char *elementName,
const void *ider, int len,
char *errorDescription);
- extern ASN1_API asn1_retCode
- asn1_der_decoding_startEnd (ASN1_TYPE element,
+ extern ASN1_API int
+ asn1_der_decoding_startEnd (asn1_node element,
const void *ider, int len,
const char *name_element,
int *start, int *end);
- extern ASN1_API asn1_retCode
- asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element);
+ extern ASN1_API int
+ asn1_expand_any_defined_by (asn1_node definitions, asn1_node * element);
- extern ASN1_API asn1_retCode
- asn1_expand_octet_string (ASN1_TYPE definitions,
- ASN1_TYPE * element,
+ extern ASN1_API int
+ asn1_expand_octet_string (asn1_node definitions,
+ asn1_node * element,
const char *octetName, const char *objectName);
- extern ASN1_API asn1_retCode
- asn1_read_tag (ASN1_TYPE root, const char *name,
+ extern ASN1_API int
+ asn1_read_tag (asn1_node root, const char *name,
int *tagValue, int *classValue);
- extern ASN1_API const char *asn1_find_structure_from_oid (ASN1_TYPE
+ extern ASN1_API const char *asn1_find_structure_from_oid (asn1_node
definitions,
const char
*oidValue);
extern ASN1_API const char *asn1_check_version (const char *req_version);
- extern ASN1_API const char *asn1_strerror (asn1_retCode error);
+ extern ASN1_API const char *asn1_strerror (int error);
- extern ASN1_API void asn1_perror (asn1_retCode error);
+ extern ASN1_API void asn1_perror (int error);
/* DER utility functions. */
asn1_octet_der (const unsigned char *str, int str_len,
unsigned char *der, int *der_len);
- extern ASN1_API asn1_retCode
+ extern ASN1_API int
asn1_get_octet_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str,
int str_size, int *str_len);
extern ASN1_API void asn1_bit_der (const unsigned char *str, int bit_len,
unsigned char *der, int *der_len);
- extern ASN1_API asn1_retCode
+ extern ASN1_API int
asn1_get_bit_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str,
int str_size, int *bit_len);
/* Other utility functions. */
- extern ASN1_API ASN1_TYPE
- asn1_find_node (ASN1_TYPE pointer, const char *name);
+ extern ASN1_API asn1_node
+ asn1_find_node (asn1_node pointer, const char *name);
+
+ extern ASN1_API int
+ asn1_copy_node (asn1_node dst, const char *dst_name,
+ asn1_node src, const char *src_name);
+
+/* Compatibility types */
+
+typedef int asn1_retCode; /* type returned by libtasn1 functions */
+
+#define node_asn_struct asn1_node_st
+#define node_asn asn1_node_st
+#define ASN1_TYPE asn1_node
+#define ASN1_TYPE_EMPTY NULL
+
+#define static_struct_asn asn1_static_node_st
+#define ASN1_ARRAY_TYPE asn1_static_node_t
- extern ASN1_API asn1_retCode
- asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
- ASN1_TYPE src, const char *src_name);
+#define node_data_struct asn1_data_node_st
+#define ASN1_DATA_NODE asn1_data_node_st
#ifdef __cplusplus
}
/***********************************************/
typedef struct list_struct
{
- ASN1_TYPE node;
+ asn1_node node;
struct list_struct *next;
} list_type;
/* and CONST_ constants). */
/* Return: pointer to the new element. */
/******************************************************/
-ASN1_TYPE
+asn1_node
_asn1_add_static_node (unsigned int type)
{
list_type *listElement;
- ASN1_TYPE punt;
+ asn1_node punt;
- punt = calloc (1, sizeof (struct node_asn_struct));
+ punt = calloc (1, sizeof (struct asn1_node_st));
if (punt == NULL)
return NULL;
*
* Returns: the search result, or %NULL if not found.
**/
-ASN1_TYPE
-asn1_find_node (ASN1_TYPE pointer, const char *name)
+asn1_node
+asn1_find_node (asn1_node pointer, const char *name)
{
- ASN1_TYPE p;
+ asn1_node p;
char *n_end, n[ASN1_MAX_NAME_SIZE + 1];
const char *n_start;
unsigned int nsize;
/* len: character number of value. */
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
-ASN1_TYPE
-_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len)
+asn1_node
+_asn1_set_value (asn1_node node, const void *value, unsigned int len)
{
if (node == NULL)
return node;
/* len: character number of value. */
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
-ASN1_TYPE
-_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len)
+asn1_node
+_asn1_set_value_octet (asn1_node node, const void *value, unsigned int len)
{
int len2;
void *temp;
/* the same as _asn1_set_value except that it sets an already malloc'ed
* value.
*/
-ASN1_TYPE
-_asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len)
+asn1_node
+_asn1_set_value_m (asn1_node node, void *value, unsigned int len)
{
if (node == NULL)
return node;
/* len: character number of value. */
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
-ASN1_TYPE
-_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len)
+asn1_node
+_asn1_append_value (asn1_node node, const void *value, unsigned int len)
{
if (node == NULL)
return node;
/* to set. */
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
-ASN1_TYPE
-_asn1_set_name (ASN1_TYPE node, const char *name)
+asn1_node
+_asn1_set_name (asn1_node node, const char *name)
{
unsigned int nsize;
/* src: a source element pointer. */
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
-ASN1_TYPE
-_asn1_cpy_name (ASN1_TYPE dst, ASN1_TYPE src)
+asn1_node
+_asn1_cpy_name (asn1_node dst, asn1_node src)
{
-unsigned int nsize;
-
if (dst == NULL)
return dst;
return dst;
}
- nsize = _asn1_str_cpy (dst->name, sizeof (dst->name), src->name);
+ _asn1_str_cpy (dst->name, sizeof (dst->name), src->name);
dst->name_hash = src->name_hash;
return dst;
/* by NODE. */
/* Return: pointer to *NODE. */
/******************************************************************/
-ASN1_TYPE
-_asn1_set_right (ASN1_TYPE node, ASN1_TYPE right)
+asn1_node
+_asn1_set_right (asn1_node node, asn1_node right)
{
if (node == NULL)
return node;
/* node: starting element pointer. */
/* Return: pointer to the last element along the right chain. */
/******************************************************************/
-ASN1_TYPE
-_asn1_get_last_right (ASN1_TYPE node)
+asn1_node
+_asn1_get_last_right (asn1_node node)
{
- ASN1_TYPE p;
+ asn1_node p;
if (node == NULL)
return NULL;
/* node: NODE_ASN element pointer. */
/******************************************************************/
void
-_asn1_remove_node (ASN1_TYPE node)
+_asn1_remove_node (asn1_node node)
{
if (node == NULL)
return;
/* node: NODE_ASN element pointer. */
/* Return: Null if not found. */
/******************************************************************/
-ASN1_TYPE
-_asn1_find_up (ASN1_TYPE node)
+asn1_node
+_asn1_find_up (asn1_node node)
{
- ASN1_TYPE p;
+ asn1_node p;
if (node == NULL)
return NULL;
/* ASN1_ELEMENT_NOT_FOUND if NODE is NULL, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
-asn1_retCode
-_asn1_change_integer_value (ASN1_TYPE node)
+int
+_asn1_change_integer_value (asn1_node node)
{
- ASN1_TYPE p;
+ asn1_node p;
unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
unsigned char val2[SIZEOF_UNSIGNED_LONG_INT + 1];
int len;
/* ASN1_ELEMENT_NOT_FOUND if NODE is NULL, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
-asn1_retCode
-_asn1_expand_object_id (ASN1_TYPE node)
+int
+_asn1_expand_object_id (asn1_node node)
{
- ASN1_TYPE p, p2, p3, p4, p5;
+ asn1_node p, p2, p3, p4, p5;
char name_root[ASN1_MAX_NAME_SIZE], name2[2 * ASN1_MAX_NAME_SIZE + 1];
int move, tlen;
/* ASN1_ELEMENT_NOT_FOUND if NODE is NULL, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
-asn1_retCode
-_asn1_type_set_config (ASN1_TYPE node)
+int
+_asn1_type_set_config (asn1_node node)
{
- ASN1_TYPE p, p2;
+ asn1_node p, p2;
int move;
if (node == NULL)
/* ASN1_IDENTIFIER_NOT_FOUND if an identifier is not defined, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
-asn1_retCode
-_asn1_check_identifier (ASN1_TYPE node)
+int
+_asn1_check_identifier (asn1_node node)
{
- ASN1_TYPE p, p2;
+ asn1_node p, p2;
char name2[ASN1_MAX_NAME_SIZE * 2 + 2];
if (node == NULL)
/* a DEFINITIONS element, */
/* otherwise ASN1_SUCCESS */
/******************************************************************/
-asn1_retCode
-_asn1_set_default_tag (ASN1_TYPE node)
+int
+_asn1_set_default_tag (asn1_node node)
{
- ASN1_TYPE p;
+ asn1_node p;
if ((node == NULL) || (type_field (node->type) != TYPE_DEFINITIONS))
return ASN1_ELEMENT_NOT_FOUND;
/***************************************/
/* Functions used by ASN.1 parser */
/***************************************/
-ASN1_TYPE _asn1_add_static_node (unsigned int type);
+asn1_node _asn1_add_static_node (unsigned int type);
-ASN1_TYPE
-_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len);
+asn1_node
+_asn1_set_value (asn1_node node, const void *value, unsigned int len);
-ASN1_TYPE _asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len);
+asn1_node _asn1_set_value_m (asn1_node node, void *value, unsigned int len);
-ASN1_TYPE
-_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len);
+asn1_node
+_asn1_set_value_octet (asn1_node node, const void *value, unsigned int len);
-ASN1_TYPE
-_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len);
+asn1_node
+_asn1_append_value (asn1_node node, const void *value, unsigned int len);
-ASN1_TYPE _asn1_set_name (ASN1_TYPE node, const char *name);
+asn1_node _asn1_set_name (asn1_node node, const char *name);
-ASN1_TYPE _asn1_cpy_name (ASN1_TYPE dst, ASN1_TYPE src);
+asn1_node _asn1_cpy_name (asn1_node dst, asn1_node src);
-ASN1_TYPE _asn1_set_right (ASN1_TYPE node, ASN1_TYPE right);
+asn1_node _asn1_set_right (asn1_node node, asn1_node right);
-ASN1_TYPE _asn1_get_last_right (ASN1_TYPE node);
+asn1_node _asn1_get_last_right (asn1_node node);
-void _asn1_remove_node (ASN1_TYPE node);
+void _asn1_remove_node (asn1_node node);
void _asn1_delete_list (void);
char *_asn1_ltostr (long v, char *str);
-ASN1_TYPE _asn1_find_up (ASN1_TYPE node);
+asn1_node _asn1_find_up (asn1_node node);
-asn1_retCode _asn1_change_integer_value (ASN1_TYPE node);
+int _asn1_change_integer_value (asn1_node node);
-asn1_retCode _asn1_expand_object_id (ASN1_TYPE node);
+int _asn1_expand_object_id (asn1_node node);
-asn1_retCode _asn1_type_set_config (ASN1_TYPE node);
+int _asn1_type_set_config (asn1_node node);
-asn1_retCode _asn1_check_identifier (ASN1_TYPE node);
+int _asn1_check_identifier (asn1_node node);
-asn1_retCode _asn1_set_default_tag (ASN1_TYPE node);
+int _asn1_set_default_tag (asn1_node node);
/******************************************************************/
/* Function : _asn1_get_right */
/* node: NODE_ASN element pointer. */
/* Return: field RIGHT of NODE. */
/******************************************************************/
-inline static ASN1_TYPE
-_asn1_get_right (ASN1_TYPE node)
+inline static asn1_node
+_asn1_get_right (asn1_node node)
{
if (node == NULL)
return NULL;
/* by NODE. */
/* Return: pointer to *NODE. */
/******************************************************************/
-inline static ASN1_TYPE
-_asn1_set_down (ASN1_TYPE node, ASN1_TYPE down)
+inline static asn1_node
+_asn1_set_down (asn1_node node, asn1_node down)
{
if (node == NULL)
return node;
/* node: NODE_ASN element pointer. */
/* Return: field DOWN of NODE. */
/******************************************************************/
-inline static ASN1_TYPE
-_asn1_get_down (ASN1_TYPE node)
+inline static asn1_node
+_asn1_get_down (asn1_node node)
{
if (node == NULL)
return NULL;
/* Return: a null terminated string. */
/******************************************************************/
inline static char *
-_asn1_get_name (ASN1_TYPE node)
+_asn1_get_name (asn1_node node)
{
if (node == NULL)
return NULL;
/* value of field TYPE. */
/* Return: NODE pointer. */
/******************************************************************/
-inline static ASN1_TYPE
-_asn1_mod_type (ASN1_TYPE node, unsigned int value)
+inline static asn1_node
+_asn1_mod_type (asn1_node node, unsigned int value)
{
if (node == NULL)
return node;
/* and CONST_ constants). */
/* Return: pointer to the new element. */
/******************************************************/
-ASN1_TYPE
+asn1_node
_asn1_add_single_node (unsigned int type)
{
- ASN1_TYPE punt;
+ asn1_node punt;
- punt = calloc (1, sizeof (struct node_asn_struct));
+ punt = calloc (1, sizeof (struct asn1_node_st));
if (punt == NULL)
return NULL;
/* node: NODE_ASN element pointer. */
/* Return: NULL if not found. */
/******************************************************************/
-ASN1_TYPE
-_asn1_find_left (ASN1_TYPE node)
+asn1_node
+_asn1_find_left (asn1_node node)
{
if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
return NULL;
}
-asn1_retCode
-_asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
+int
+_asn1_create_static_structure (asn1_node pointer, char *output_file_name,
char *vector_name)
{
FILE *file;
- ASN1_TYPE p;
+ asn1_node p;
unsigned long t;
file = fopen (output_file_name, "w");
fprintf (file, "#include <libtasn1.h>\n\n");
- fprintf (file, "const ASN1_ARRAY_TYPE %s[] = {\n", vector_name);
+ fprintf (file, "const asn1_static_node_t %s[] = {\n", vector_name);
p = pointer;
* @array is a vector created by asn1_parser2array().
*
* Returns: %ASN1_SUCCESS if structure was created correctly,
- * %ASN1_ELEMENT_NOT_EMPTY if *@definitions not ASN1_TYPE_EMPTY,
+ * %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.
**/
-asn1_retCode
-asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
+int
+asn1_array2tree (const asn1_static_node_t * array, asn1_node * definitions,
char *errorDescription)
{
- ASN1_TYPE p, p_last = NULL;
+ asn1_node p, p_last = NULL;
unsigned long k;
int move;
- asn1_retCode result;
+ int result;
- if (*definitions != ASN1_TYPE_EMPTY)
+ if (*definitions != NULL)
return ASN1_ELEMENT_NOT_EMPTY;
move = UP;
if (result != ASN1_SUCCESS)
{
_asn1_delete_list_and_nodes ();
- *definitions = ASN1_TYPE_EMPTY;
+ *definitions = NULL;
}
else
_asn1_delete_list ();
* @structure: pointer to the structure that you want to delete.
*
* Deletes the structure *@structure. At the end, *@structure is set
- * to ASN1_TYPE_EMPTY.
+ * to NULL.
*
* Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if
- * *@structure was ASN1_TYPE_EMPTY.
+ * *@structure was NULL.
**/
-asn1_retCode
-asn1_delete_structure (ASN1_TYPE * structure)
+int
+asn1_delete_structure (asn1_node * structure)
{
- ASN1_TYPE p, p2, p3;
+ asn1_node p, p2, p3;
- if (*structure == ASN1_TYPE_EMPTY)
+ if (*structure == NULL)
return ASN1_ELEMENT_NOT_FOUND;
p = *structure;
}
}
- *structure = ASN1_TYPE_EMPTY;
+ *structure = NULL;
return ASN1_SUCCESS;
}
* Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if
* the @element_name was not found.
**/
-asn1_retCode
-asn1_delete_element (ASN1_TYPE structure, const char *element_name)
+int
+asn1_delete_element (asn1_node structure, const char *element_name)
{
- ASN1_TYPE p2, p3, source_node;
+ asn1_node p2, p3, source_node;
source_node = asn1_find_node (structure, element_name);
- if (source_node == ASN1_TYPE_EMPTY)
+ if (source_node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
p2 = source_node->right;
return asn1_delete_structure (&source_node);
}
-ASN1_TYPE
-_asn1_copy_structure3 (ASN1_TYPE source_node)
+asn1_node
+_asn1_copy_structure3 (asn1_node source_node)
{
- ASN1_TYPE dest_node, p_s, p_d, p_d_prev;
+ asn1_node dest_node, p_s, p_d, p_d_prev;
int move;
if (source_node == NULL)
}
-static ASN1_TYPE
-_asn1_copy_structure2 (ASN1_TYPE root, const char *source_name)
+static asn1_node
+_asn1_copy_structure2 (asn1_node root, const char *source_name)
{
- ASN1_TYPE source_node;
+ asn1_node source_node;
source_node = asn1_find_node (root, source_name);
}
-static asn1_retCode
-_asn1_type_choice_config (ASN1_TYPE node)
+static int
+_asn1_type_choice_config (asn1_node node)
{
- ASN1_TYPE p, p2, p3, p4;
+ asn1_node p, p2, p3, p4;
int move, tlen;
if (node == NULL)
}
-static asn1_retCode
-_asn1_expand_identifier (ASN1_TYPE * node, ASN1_TYPE root)
+static int
+_asn1_expand_identifier (asn1_node * node, asn1_node root)
{
- ASN1_TYPE p, p2, p3;
+ asn1_node p, p2, p3;
char name2[ASN1_MAX_NAME_SIZE + 2];
int move;
* Returns: %ASN1_SUCCESS if creation OK, %ASN1_ELEMENT_NOT_FOUND if
* @source_name is not known.
**/
-asn1_retCode
-asn1_create_element (ASN1_TYPE definitions, const char *source_name,
- ASN1_TYPE * element)
+int
+asn1_create_element (asn1_node definitions, const char *source_name,
+ asn1_node * element)
{
- ASN1_TYPE dest_node;
+ asn1_node dest_node;
int res;
dest_node = _asn1_copy_structure2 (definitions, source_name);
* from the @name element inside the structure @structure.
**/
void
-asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
+asn1_print_structure (FILE * out, asn1_node structure, const char *name,
int mode)
{
- ASN1_TYPE p, root;
+ asn1_node p, root;
int k, indent = 0, len, len2, len3;
if (out == NULL)
* Returns: %ASN1_SUCCESS if successful, %ASN1_ELEMENT_NOT_FOUND if
* @name is not known, %ASN1_GENERIC_ERROR if pointer @num is %NULL.
**/
-asn1_retCode
-asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
+int
+asn1_number_of_elements (asn1_node element, const char *name, int *num)
{
- ASN1_TYPE node, p;
+ asn1_node node, p;
if (num == NULL)
return ASN1_GENERIC_ERROR;
* the OID.
**/
const char *
-asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
+asn1_find_structure_from_oid (asn1_node definitions, const char *oidValue)
{
char definitionsName[ASN1_MAX_NAME_SIZE], name[2 * ASN1_MAX_NAME_SIZE + 1];
char value[ASN1_MAX_NAME_SIZE];
- ASN1_TYPE p;
+ asn1_node p;
int len;
- asn1_retCode result;
+ int result;
- if ((definitions == ASN1_TYPE_EMPTY) || (oidValue == NULL))
+ if ((definitions == NULL) || (oidValue == NULL))
return NULL; /* ASN1_ELEMENT_NOT_FOUND; */
/**
* asn1_copy_node:
- * @dst: Destination ASN1_TYPE node.
+ * @dst: Destination asn1_node node.
* @dst_name: Field name in destination node.
- * @src: Source ASN1_TYPE node.
+ * @src: Source asn1_node node.
* @src_name: Field name in source node.
*
- * Create a deep copy of a ASN1_TYPE variable.
+ * Create a deep copy of a asn1_node variable.
*
* Returns: Return %ASN1_SUCCESS on success.
**/
-asn1_retCode
-asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
- ASN1_TYPE src, const char *src_name)
+int
+asn1_copy_node (asn1_node dst, const char *dst_name,
+ asn1_node src, const char *src_name)
{
/* FIXME: rewrite using copy_structure().
* It seems quite hard to do.
*/
int result;
- ASN1_TYPE dst_node;
+ asn1_node dst_node;
void *data = NULL;
int size = 0;
#ifndef _STRUCTURE_H
#define _STRUCTURE_H
-asn1_retCode _asn1_create_static_structure (ASN1_TYPE pointer,
+int _asn1_create_static_structure (asn1_node pointer,
char *output_file_name,
char *vector_name);
-ASN1_TYPE _asn1_copy_structure3 (ASN1_TYPE source_node);
+asn1_node _asn1_copy_structure3 (asn1_node source_node);
-ASN1_TYPE _asn1_add_single_node (unsigned int type);
+asn1_node _asn1_add_single_node (unsigned int type);
-ASN1_TYPE _asn1_find_left (ASN1_TYPE node);
+asn1_node _asn1_find_left (asn1_node node);
#endif
projects / thirdparty / gnutls.git / commitdiff
