* Version 2.7.10 (unreleased)
+** minitasn1: Internal copy updated to libtasn1 v2.1.
+GnuTLS should work fine with libtasn1 v1.x and that is still
+supported.
+
** API and ABI modifications:
No changes since last version.
/*****************************************************/
#include <int.h>
-#include <errors.h>
#include "parser_aux.h"
#include <gstr.h>
#include "element.h"
/* ErrorDescription: string returned. */
/* Return: */
/******************************************************/
-void
-_asn1_error_description_value_not_found (ASN1_TYPE node,
+static void
+_asn1_error_description_value_not_found (ASN1_TYPE node,
char *ErrorDescription)
{
/* (ans[0]..ans[ans_len-1]). */
/* Return: */
/******************************************************/
-void
+static void
_asn1_tag_der (unsigned char class, unsigned int tag_value,
unsigned char *ans, int *ans_len)
{
/* ASN1_MEM_ERROR when DER isn't big enough */
/* ASN1_SUCCESS otherwise */
/******************************************************/
-asn1_retCode
+static asn1_retCode
_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 */
/******************************************************/
-asn1_retCode
+static asn1_retCode
_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. */
/******************************************************/
-asn1_retCode
-_asn1_complete_explicit_tag (ASN1_TYPE node, unsigned char *der,
+static asn1_retCode
+_asn1_complete_explicit_tag (ASN1_TYPE node, unsigned char *der,
int *counter, int *max_len)
{
ASN1_TYPE p;
/* ASN1_MEM_ERROR if der vector isn't big enough, */
/* otherwise ASN1_SUCCESS. */
/******************************************************/
-asn1_retCode
-_asn1_insert_tag_der (ASN1_TYPE node, unsigned char *der, int *counter,
+static asn1_retCode
+_asn1_insert_tag_der (ASN1_TYPE node, unsigned char *der, int *counter,
int *max_len)
{
ASN1_TYPE p;
/* node: pointer to the SET element. */
/* Return: */
/******************************************************/
-void
-_asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE node)
+static void
+_asn1_ordering_set (unsigned char *der, int der_len, ASN1_TYPE node)
{
struct vet
{
/* node: pointer to the SET OF element. */
/* Return: */
/******************************************************/
-void
-_asn1_ordering_set_of (unsigned char *der, int der_len, ASN1_TYPE node)
+static void
+_asn1_ordering_set_of (unsigned char *der, int der_len, ASN1_TYPE node)
{
struct vet
{
/*****************************************************/
#include <int.h>
-#include <errors.h>
#include "parser_aux.h"
#include <gstr.h>
#include "structure.h"
int ret;
long err;
- ret = asn1_get_length_der( ber, ber_len, len);
+ ret = asn1_get_length_der (ber, ber_len, len);
if (ret == -1)
- { /* indefinite length method */
+ { /* indefinite length method */
ret = ber_len;
- err = _asn1_get_indefinite_length_string (ber+1, &ret);
+ err = _asn1_get_indefinite_length_string (ber + 1, &ret);
if (err != ASN1_SUCCESS)
return -3;
}
/* Returns ASN1_SUCCESS on success or an error code on error.
*/
-int
+static int
_asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
char *str, int str_size)
{
-void
+static void
_asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
char *str, int str_size)
{
-int
+static int
_asn1_extract_tag_der (ASN1_TYPE node, const unsigned char *der, int der_len,
int *ret_len)
{
&len2);
if (len3 < 0)
return ASN1_DER_ERROR;
-
+
counter += len2;
if (counter > der_len)
return ASN1_DER_ERROR;
}
-int
+static int
_asn1_delete_not_used (ASN1_TYPE node)
{
ASN1_TYPE p, p2;
return ASN1_SUCCESS;
}
-asn1_retCode _asn1_extract_der_octet(ASN1_TYPE node, const unsigned char *der, int der_len)
+static asn1_retCode
+_asn1_extract_der_octet (ASN1_TYPE node, const unsigned char *der,
+ int der_len)
{
-int len2, len3;
-int counter2, counter_end;
+ int len2, len3;
+ int counter2, counter_end;
- len2 = asn1_get_length_der (der, der_len, &len3);
- if (len2 < -1)
- return ASN1_DER_ERROR;
+ len2 = asn1_get_length_der (der, der_len, &len3);
+ if (len2 < -1)
+ return ASN1_DER_ERROR;
- counter2 = len3 + 1;
+ counter2 = len3 + 1;
- if (len2 == -1)
- counter_end = der_len - 2;
- else
- counter_end = der_len;
+ if (len2 == -1)
+ counter_end = der_len - 2;
+ else
+ counter_end = der_len;
- while (counter2 < counter_end)
- {
- len2 = asn1_get_length_der (der + counter2, der_len - counter2, &len3);
+ while (counter2 < counter_end)
+ {
+ len2 = asn1_get_length_der (der + counter2, der_len - counter2, &len3);
- if (len2 < -1)
- return ASN1_DER_ERROR;
+ if (len2 < -1)
+ return ASN1_DER_ERROR;
- if (len2 > 0)
- {
- _asn1_append_value( node, der + counter2 + len3, len2);
- }
- else
- { /* indefinite */
-
- len2 = _asn1_extract_der_octet( node, der+counter2+len3, der_len-counter2-len3);
- if (len2 < 0)
- return len2;
- }
-
- counter2 += len2 + len3 + 1;
- }
-
- return ASN1_SUCCESS;
+ if (len2 > 0)
+ {
+ _asn1_append_value (node, der + counter2 + len3, len2);
+ }
+ else
+ { /* indefinite */
+
+ len2 =
+ _asn1_extract_der_octet (node, der + counter2 + len3,
+ der_len - counter2 - len3);
+ if (len2 < 0)
+ return len2;
+ }
+
+ counter2 += len2 + len3 + 1;
+ }
+
+ return ASN1_SUCCESS;
}
-asn1_retCode
+static asn1_retCode
_asn1_get_octet_string (const unsigned char *der, ASN1_TYPE node, int *len)
{
int len2, len3, counter, tot_len, indefinite;
{
unsigned char temp[DER_LEN];
int ret;
-
- len2 = sizeof(temp);
+
+ len2 = sizeof (temp);
asn1_length_der (tot_len, temp, &len2);
_asn1_set_value (node, temp, len2);
tot_len += len2;
- ret = _asn1_extract_der_octet(node, der, *len);
- if (ret!=ASN1_SUCCESS)
- return ret;
+ ret = _asn1_extract_der_octet (node, der, *len);
+ if (ret != ASN1_SUCCESS)
+ return ret;
}
}
if (len4 != -1)
{
len2 += len4;
- _asn1_set_value_octet (p, der+counter, len2+len3);
+ _asn1_set_value_octet (p, der + counter, len2 + len3);
counter += len2 + len3;
}
else
return ris;
}
- _asn1_set_value_octet (p, der+counter, len2);
+ _asn1_set_value_octet (p, der + counter, len2);
counter += len2;
/* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
len2 += len4;
if (state == FOUND)
{
- _asn1_set_value_octet (p, der+counter, len2+len3);
+ _asn1_set_value_octet (p, der + counter, len2 + len3);
temp2 = NULL;
if (p == nodeFound)
if (state == FOUND)
{
- _asn1_set_value_octet (p, der+counter, len2);
+ _asn1_set_value_octet (p, der + counter, len2);
if (p == nodeFound)
state = EXIT;
#include <int.h>
-#include <errors.h>
#include "parser_aux.h"
#include <gstr.h>
#include "structure.h"
+#include "element.h"
+
void
-_asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size)
+_asn1_hierarchical_name (ASN1_TYPE node, char *name, int name_size)
{
ASN1_TYPE p;
char tmp_name[64];
for (k2 = k; k2 < SIZEOF_UNSIGNED_LONG_INT; k2++)
value_out[k2 - k] = val[k2];
-
-#ifdef LIBTASN1_DEBUG_INTEGER
- _libtasn1_log ("_asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
+#if 0
+ printf ("_asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
- _libtasn1_log (", vOut[%d]=%d", k, value_out[k]);
- _libtasn1_log ("\n");
+ printf (", vOut[%d]=%d", k, value_out[k]);
+ printf ("\n");
#endif
-
return ASN1_SUCCESS;
}
int
-_asn1_append_sequence_set (ASN1_TYPE node)
+_asn1_append_sequence_set (ASN1_TYPE node)
{
ASN1_TYPE p, p2;
char temp[10];
ASN1_TYPE node, p, p2;
unsigned char *temp, *value_temp = NULL, *default_temp = NULL;
int len2, k, k2, negative;
+ size_t i;
const unsigned char *value = ivalue;
node = asn1_find_node (node_root, name);
(!negative && (value_temp[k] & 0x80)))
k--;
- _asn1_set_value_octet (node, value_temp+k, len-k);
+ _asn1_set_value_octet (node, value_temp + k, len - k);
if (node->type & CONST_DEFAULT)
{
_asn1_free (value_temp);
break;
case TYPE_OBJECT_ID:
- for (k = 0; k < strlen (value); k++)
- if ((!isdigit (value[k])) && (value[k] != '.') && (value[k] != '+'))
+ for (i = 0; i < strlen (value); i++)
+ if ((!isdigit (value[i])) && (value[i] != '.') && (value[i] != '+'))
return ASN1_VALUE_NOT_VALID;
if (node->type & CONST_DEFAULT)
{
}
#define ADD_STR_VALUE( ptr, ptr_size, data) \
- *len = strlen(data) + 1; \
- if (ptr_size < strlen(ptr)+(*len)) { \
+ *len = (int) strlen(data) + 1; \
+ if (ptr_size < (int) strlen(ptr)+(*len)) { \
return ASN1_MEM_ERROR; \
} else { \
/* this strcat is checked */ \
#define _ELEMENT_H
-asn1_retCode _asn1_append_sequence_set(ASN1_TYPE node);
+asn1_retCode _asn1_append_sequence_set (ASN1_TYPE node);
-asn1_retCode _asn1_convert_integer(const char *value,unsigned char *value_out,
- int value_out_size, int *len);
+asn1_retCode _asn1_convert_integer (const 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_TYPE node, char *name, int name_size);
#endif
*/
#include <int.h>
-#include "errors.h"
#ifdef STDC_HEADERS
# include <stdarg.h>
#endif
LIBTASN1_ERROR_ENTRY (ASN1_NAME_TOO_LONG),
LIBTASN1_ERROR_ENTRY (ASN1_ARRAY_ERROR),
LIBTASN1_ERROR_ENTRY (ASN1_ELEMENT_NOT_EMPTY),
- {0}
+ {0, 0}
};
/**
* asn1_perror - prints a string to stderr with a description of an error
* @error: is an error returned by a libtasn1 function.
*
- * This function is like perror(). The only difference is that it
+ * This function is like perror(). The only difference is that it
* accepts an error returned by a libtasn1 function.
*
+ * This function replaces libtasn1_perror() in older libtasn1.
+ *
* Since: 1.6
**/
void
* asn1_strerror - Returns a string with a description of an error
* @error: is an error returned by a libtasn1 function.
*
- * This function is similar to strerror(). The only difference is
+ * This function is similar to strerror(). The only difference is
* that it accepts an error (number) returned by a libtasn1 function.
*
+ * This function replaces libtasn1_strerror() in older libtasn1.
+ *
* Returns: Pointer to static zero-terminated string describing error
* code.
*
*/
#include <int.h>
+#include "gstr.h"
/* These function are like strcat, strcpy. They only
* do bounds checking (they shouldn't cause buffer overruns),
-void _asn1_str_cpy( char* dest, size_t dest_tot_size, const char* src);
-void _asn1_str_cat( char* dest, size_t dest_tot_size, const char* src);
+void _asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src);
+void _asn1_str_cat (char *dest, size_t dest_tot_size, const char *src);
#define Estrcpy(x,y) _asn1_str_cpy(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
#define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
#include <libtasn1.h>
-/*
-#define LIBTASN1_DEBUG
-#define LIBTASN1_DEBUG_PARSER
-#define LIBTASN1_DEBUG_INTEGER
-*/
+#define ASN1_SMALL_VALUE_SIZE 16
+
+/* 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
+{
+ /* public fields: */
+ char *name; /* 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 */
+ /* private fields: */
+ unsigned char small_value[ASN1_SMALL_VALUE_SIZE]; /* For small values */
+};
#define _asn1_malloc malloc
#define _asn1_free free
#define _asn1_realloc realloc
#define _asn1_strdup strdup
-#define MAX_LOG_SIZE 1024 /* maximum number of characters of a log message */
+#define MAX_LOG_SIZE 1024 /* maximum number of characters of a log message */
/* Define used for visiting trees. */
#define UP 1
#define CONST_EXPLICIT (1<<11)
#define CONST_IMPLICIT (1<<12)
-#define CONST_TAG (1<<13) /* Used in ASN.1 assignement */
+#define CONST_TAG (1<<13) /* Used in ASN.1 assignement */
#define CONST_OPTION (1<<14)
#define CONST_DEFAULT (1<<15)
#define CONST_TRUE (1<<16)
#define CONST_FALSE (1<<17)
-#define CONST_LIST (1<<18) /* Used with TYPE_INTEGER and TYPE_BIT_STRING */
+#define CONST_LIST (1<<18) /* Used with TYPE_INTEGER and TYPE_BIT_STRING */
#define CONST_MIN_MAX (1<<19)
#define CONST_1_PARAM (1<<20)
#ifndef LIBTASN1_H
# define LIBTASN1_H
+# ifndef ASN1_API
+# if defined ASN1_BUILDING && defined HAVE_VISIBILITY && HAVE_VISIBILITY
+# define ASN1_API __attribute__((__visibility__("default")))
+# elif defined ASN1_BUILDING && defined _MSC_VER && ! defined ASN1_STATIC
+# define ASN1_API __declspec(dllexport)
+# elif defined _MSC_VER && ! defined ASN1_STATIC
+# define ASN1_API __declspec(dllimport)
+# else
+# define ASN1_API
+# endif
+# endif
+
#include <stdio.h> /* for FILE* */
#include <sys/types.h>
#include <time.h>
#ifdef __cplusplus
-extern "C" {
+extern "C"
+{
#endif
-#define ASN1_VERSION "1.8"
+#define ASN1_VERSION "2.1"
typedef int asn1_retCode; /* type returned by libtasn1 functions */
/* that represent an ASN.1 DEFINITION. */
/******************************************************/
+#if !defined(ASN1_BUILDING)
+ /* This structure is also in internal.h, but then contains more
+ fields. You cannot make any modifications to these fields
+ without breaking ABI. */
struct node_asn_struct
{
char *name; /* Node name */
struct node_asn_struct *right; /* Pointer to the brother node */
struct node_asn_struct *left; /* Pointer to the next list element */
};
+#endif
typedef struct node_asn_struct node_asn;
/*****************************************/
struct static_struct_asn
{
- const char *name; /* Node name */
- unsigned int type; /* Node type */
- const void *value; /* Node value */
+ const char *name; /* Node name */
+ unsigned int type; /* Node type */
+ const void *value; /* Node value */
};
typedef struct static_struct_asn ASN1_ARRAY_TYPE;
asn1_retCode asn1_parser2tree (const char *file_name,
ASN1_TYPE * definitions,
- char *errorDescription);
+ char *errorDescription) ASN1_API;
asn1_retCode asn1_parser2array (const char *inputFileName,
const char *outputFileName,
const char *vectorName,
- char *errorDescription);
+ char *errorDescription) ASN1_API;
asn1_retCode asn1_array2tree (const ASN1_ARRAY_TYPE * array,
ASN1_TYPE * definitions,
- char *errorDescription);
+ char *errorDescription) ASN1_API;
- void asn1_print_structure (FILE *out, ASN1_TYPE structure, const char *name,
- int mode);
+ void asn1_print_structure (FILE * out, ASN1_TYPE structure,
+ const char *name, int mode) ASN1_API;
asn1_retCode asn1_create_element (ASN1_TYPE definitions,
const char *source_name,
- ASN1_TYPE * element);
+ ASN1_TYPE * element) ASN1_API;
- asn1_retCode asn1_delete_structure (ASN1_TYPE * structure);
+ asn1_retCode asn1_delete_structure (ASN1_TYPE * structure) ASN1_API;
asn1_retCode asn1_delete_element (ASN1_TYPE structure,
- const char *element_name);
+ const char *element_name) ASN1_API;
asn1_retCode asn1_write_value (ASN1_TYPE node_root, const char *name,
- const void *ivalue, int len);
+ const void *ivalue, int len) ASN1_API;
asn1_retCode asn1_read_value (ASN1_TYPE root, const char *name,
- void *ivalue, int *len);
+ void *ivalue, int *len) ASN1_API;
asn1_retCode asn1_number_of_elements (ASN1_TYPE element, const char *name,
- int *num);
+ int *num) ASN1_API;
asn1_retCode asn1_der_coding (ASN1_TYPE element, const char *name,
- void *ider, int *len, char *ErrorDescription);
+ void *ider, int *len,
+ char *ErrorDescription) ASN1_API;
asn1_retCode asn1_der_decoding (ASN1_TYPE * element, const void *ider,
- int len, char *errorDescription);
+ int len, char *errorDescription) ASN1_API;
asn1_retCode asn1_der_decoding_element (ASN1_TYPE * structure,
const char *elementName,
const void *ider, int len,
- char *errorDescription);
+ char *errorDescription) ASN1_API;
asn1_retCode asn1_der_decoding_startEnd (ASN1_TYPE element,
const void *ider, int len,
const char *name_element,
- int *start, int *end);
+ int *start, int *end) ASN1_API;
asn1_retCode asn1_expand_any_defined_by (ASN1_TYPE definitions,
- ASN1_TYPE * element);
+ ASN1_TYPE * element) ASN1_API;
asn1_retCode asn1_expand_octet_string (ASN1_TYPE definitions,
ASN1_TYPE * element,
const char *octetName,
- const char *objectName);
+ const char *objectName) ASN1_API;
asn1_retCode asn1_read_tag (ASN1_TYPE root, const char *name,
- int *tagValue, int *classValue);
+ int *tagValue, int *classValue) ASN1_API;
const char *asn1_find_structure_from_oid (ASN1_TYPE definitions,
- const char *oidValue);
+ const char *oidValue) ASN1_API;
- const char *asn1_check_version (const char *req_version);
+ const char *asn1_check_version (const char *req_version) ASN1_API;
- const char *asn1_strerror (asn1_retCode error);
- void asn1_perror (asn1_retCode error);
+ const char *asn1_strerror (asn1_retCode error) ASN1_API;
+ void asn1_perror (asn1_retCode error) ASN1_API;
/* DER utility functions. */
int asn1_get_tag_der (const unsigned char *der, int der_len,
- unsigned char *cls, int *len, unsigned long *tag);
+ unsigned char *cls, int *len,
+ unsigned long *tag) ASN1_API;
void asn1_octet_der (const unsigned char *str, int str_len,
- unsigned char *der, int *der_len);
+ unsigned char *der, int *der_len) ASN1_API;
asn1_retCode asn1_get_octet_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str,
- int str_size, int *str_len);
+ int str_size, int *str_len) ASN1_API;
void asn1_bit_der (const unsigned char *str, int bit_len,
- unsigned char *der, int *der_len);
+ unsigned char *der, int *der_len) ASN1_API;
asn1_retCode asn1_get_bit_der (const unsigned char *der, int der_len,
int *ret_len, unsigned char *str,
- int str_size, int *bit_len);
+ int str_size, int *bit_len) ASN1_API;
signed long asn1_get_length_der (const unsigned char *der, int der_len,
- int *len);
+ int *len) ASN1_API;
signed long asn1_get_length_ber (const unsigned char *ber, int ber_len,
- int *len);
+ int *len) ASN1_API;
void asn1_length_der (unsigned long int len, unsigned char *ans,
- int *ans_len);
+ int *ans_len) ASN1_API;
/* Other utility functions. */
- ASN1_TYPE asn1_find_node (ASN1_TYPE pointer, const char *name);
+ ASN1_TYPE asn1_find_node (ASN1_TYPE pointer, const char *name) ASN1_API;
asn1_retCode asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
- ASN1_TYPE src, const char *src_name);
-
+ ASN1_TYPE src, const char *src_name) ASN1_API;
/* Deprecated stuff. */
/* Use asn1_strerror instead. */
const char *libtasn1_strerror (asn1_retCode error)
- __attribute__ ((deprecated));
+ __attribute__ ((deprecated)) ASN1_API;
/* Use asn1_perror instead. */
void libtasn1_perror (asn1_retCode error)
- __attribute__ ((deprecated));
+ __attribute__ ((deprecated)) ASN1_API;
#endif
*/
#include <int.h>
-#include <errors.h>
#include "parser_aux.h"
#include "gstr.h"
#include "structure.h"
/* 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_TYPE
+_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len)
{
if (node == NULL)
return node;
if (node->value)
{
- _asn1_free (node->value);
+ if (node->value != node->small_value)
+ _asn1_free (node->value);
node->value = NULL;
node->value_len = 0;
}
if (!len)
return node;
- node->value = (unsigned char *) _asn1_malloc (len);
- if (node->value == NULL)
- return NULL;
+ if (len < sizeof (node->small_value))
+ {
+ node->value = node->small_value;
+ }
+ else
+ {
+ node->value = _asn1_malloc (len);
+ if (node->value == NULL)
+ return NULL;
+ }
node->value_len = len;
memcpy (node->value, value, len);
/* Function : _asn1_set_value_octet */
/* Description: sets the field VALUE in a NODE_ASN element. The */
/* previous value (if exist) will be lost. The value */
-/* given is stored as an octet string. */
+/* given is stored as an octet string. */
/* Parameters: */
/* node: element pointer. */
/* value: pointer to the value that you want to set. */
/* 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_TYPE
+_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len)
{
-int len2;
-void* temp;
+ int len2;
+ void *temp;
if (node == NULL)
return node;
/* 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_TYPE
+_asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len)
{
if (node == NULL)
return node;
if (node->value)
{
- _asn1_free (node->value);
+ if (node->value != node->small_value)
+ _asn1_free (node->value);
node->value = NULL;
node->value_len = 0;
}
/******************************************************************/
/* Function : _asn1_append_value */
/* Description: appends to the field VALUE in a NODE_ASN element. */
-/* */
+/* */
/* Parameters: */
/* node: element pointer. */
/* value: pointer to the value that you want to be appended. */
/* 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_TYPE
+_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len)
{
if (node == NULL)
return node;
- if (node->value != NULL) /* value is allocated */
+ if (node->value != NULL && node->value != node->small_value)
{
+ /* value is allocated */
int prev_len = node->value_len;
- node->value_len+=len;
- node->value = _asn1_realloc( node->value, node->value_len);
- if (node->value == NULL) {
- node->value_len = 0;
- return NULL;
- }
- memcpy( &node->value[prev_len], value, len);
+ node->value_len += len;
+ node->value = _asn1_realloc (node->value, node->value_len);
+ if (node->value == NULL)
+ {
+ node->value_len = 0;
+ return NULL;
+ }
+ memcpy (&node->value[prev_len], value, len);
return node;
}
- else /* node->value == NULL */
- return _asn1_set_value(node, value, len);
+ else if (node->value == node->small_value)
+ {
+ /* value is in node */
+ int prev_len = node->value_len;
+ node->value_len += len;
+ node->value = _asn1_malloc (node->value_len);
+ if (node->value == NULL)
+ {
+ node->value_len = 0;
+ return NULL;
+ }
+ memcpy (node->value, node->small_value, prev_len);
+ memcpy (&node->value[prev_len], value, len);
+
+ return node;
+ }
+ else /* node->value == NULL */
+ return _asn1_set_value (node, value, len);
}
/******************************************************************/
/* to set. */
/* Return: pointer to the NODE_ASN element. */
/******************************************************************/
-ASN1_TYPE
-_asn1_set_name (ASN1_TYPE node, const char *name)
+ASN1_TYPE
+_asn1_set_name (ASN1_TYPE node, const char *name)
{
if (node == NULL)
return node;
/* by NODE. */
/* Return: pointer to *NODE. */
/******************************************************************/
-ASN1_TYPE
-_asn1_set_right (ASN1_TYPE node, ASN1_TYPE right)
+ASN1_TYPE
+_asn1_set_right (ASN1_TYPE node, ASN1_TYPE right)
{
if (node == NULL)
return node;
/* node: NODE_ASN element pointer. */
/* Return: field RIGHT of NODE. */
/******************************************************************/
-ASN1_TYPE
-_asn1_get_right (ASN1_TYPE node)
+ASN1_TYPE
+_asn1_get_right (ASN1_TYPE node)
{
if (node == NULL)
return NULL;
/* node: starting element pointer. */
/* Return: pointer to the last element along the right chain. */
/******************************************************************/
-ASN1_TYPE
-_asn1_get_last_right (ASN1_TYPE node)
+ASN1_TYPE
+_asn1_get_last_right (ASN1_TYPE node)
{
ASN1_TYPE p;
/* by NODE. */
/* Return: pointer to *NODE. */
/******************************************************************/
-ASN1_TYPE
-_asn1_set_down (ASN1_TYPE node, ASN1_TYPE down)
+ASN1_TYPE
+_asn1_set_down (ASN1_TYPE node, ASN1_TYPE down)
{
if (node == NULL)
return node;
/* node: NODE_ASN element pointer. */
/* Return: field DOWN of NODE. */
/******************************************************************/
-ASN1_TYPE
-_asn1_get_down (ASN1_TYPE node)
+ASN1_TYPE
+_asn1_get_down (ASN1_TYPE node)
{
if (node == NULL)
return NULL;
/* Return: a null terminated string. */
/******************************************************************/
char *
-_asn1_get_name (ASN1_TYPE node)
+_asn1_get_name (ASN1_TYPE node)
{
if (node == NULL)
return NULL;
/* value of field TYPE. */
/* Return: NODE pointer. */
/******************************************************************/
-ASN1_TYPE
-_asn1_mod_type (ASN1_TYPE node, unsigned int value)
+ASN1_TYPE
+_asn1_mod_type (ASN1_TYPE node, unsigned int value)
{
if (node == NULL)
return node;
/* node: NODE_ASN element pointer. */
/******************************************************************/
void
-_asn1_remove_node (ASN1_TYPE node)
+_asn1_remove_node (ASN1_TYPE node)
{
if (node == NULL)
return;
if (node->name != NULL)
_asn1_free (node->name);
- if (node->value != NULL)
+ if (node->value != NULL && node->value != node->small_value)
_asn1_free (node->value);
_asn1_free (node);
}
/* node: NODE_ASN element pointer. */
/* Return: Null if not found. */
/******************************************************************/
-ASN1_TYPE
-_asn1_find_up (ASN1_TYPE node)
+ASN1_TYPE
+_asn1_find_up (ASN1_TYPE node)
{
ASN1_TYPE p;
/***************************************/
/* Functions used by ASN.1 parser */
/***************************************/
-ASN1_TYPE
-_asn1_add_node(unsigned int type);
+ASN1_TYPE _asn1_add_node (unsigned int type);
ASN1_TYPE
-_asn1_set_value(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_set_value (ASN1_TYPE node, const void *value, unsigned int len);
-ASN1_TYPE
-_asn1_set_value_m(ASN1_TYPE node,void *value,unsigned int len);
+ASN1_TYPE _asn1_set_value_m (ASN1_TYPE node, void *value, unsigned int len);
ASN1_TYPE
-_asn1_set_value_octet(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_set_value_octet (ASN1_TYPE node, const void *value, unsigned int len);
ASN1_TYPE
-_asn1_append_value(ASN1_TYPE node,const void *value,unsigned int len);
+_asn1_append_value (ASN1_TYPE node, const void *value, unsigned int len);
-ASN1_TYPE
-_asn1_set_name(ASN1_TYPE node,const char *name);
+ASN1_TYPE _asn1_set_name (ASN1_TYPE node, const char *name);
-ASN1_TYPE
-_asn1_set_right(ASN1_TYPE node, ASN1_TYPE right);
+ASN1_TYPE _asn1_set_right (ASN1_TYPE node, ASN1_TYPE right);
-ASN1_TYPE
-_asn1_get_right(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_right (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_get_last_right(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_last_right (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_set_down(ASN1_TYPE node, ASN1_TYPE down);
+ASN1_TYPE _asn1_set_down (ASN1_TYPE node, ASN1_TYPE down);
-char *
-_asn1_get_name(ASN1_TYPE node);
+char *_asn1_get_name (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_get_down(ASN1_TYPE node);
+ASN1_TYPE _asn1_get_down (ASN1_TYPE node);
-ASN1_TYPE
-_asn1_mod_type(ASN1_TYPE node,unsigned int value);
+ASN1_TYPE _asn1_mod_type (ASN1_TYPE node, unsigned int value);
-void
-_asn1_remove_node(ASN1_TYPE node);
+void _asn1_remove_node (ASN1_TYPE node);
-void _asn1_delete_list(void);
+void _asn1_delete_list (void);
-void _asn1_delete_list_and_nodes(void);
+void _asn1_delete_list_and_nodes (void);
-char * _asn1_ltostr(long v,char *str);
+char *_asn1_ltostr (long v, char *str);
-ASN1_TYPE _asn1_find_up(ASN1_TYPE node);
+ASN1_TYPE _asn1_find_up (ASN1_TYPE node);
-asn1_retCode _asn1_change_integer_value(ASN1_TYPE node);
+asn1_retCode _asn1_change_integer_value (ASN1_TYPE node);
-asn1_retCode _asn1_expand_object_id(ASN1_TYPE node);
+asn1_retCode _asn1_expand_object_id (ASN1_TYPE node);
-asn1_retCode _asn1_type_set_config(ASN1_TYPE node);
+asn1_retCode _asn1_type_set_config (ASN1_TYPE node);
-asn1_retCode _asn1_check_identifier(ASN1_TYPE node);
+asn1_retCode _asn1_check_identifier (ASN1_TYPE node);
-asn1_retCode _asn1_set_default_tag(ASN1_TYPE node);
+asn1_retCode _asn1_set_default_tag (ASN1_TYPE node);
#endif
-
-
-
#include <int.h>
-#include <errors.h>
#include <structure.h>
#include "parser_aux.h"
#include <gstr.h>
/* Return: NULL if not found. */
/******************************************************************/
ASN1_TYPE
-_asn1_find_left (ASN1_TYPE node)
+_asn1_find_left (ASN1_TYPE node)
{
if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
return NULL;
}
ASN1_TYPE
-_asn1_copy_structure3 (ASN1_TYPE source_node)
+_asn1_copy_structure3 (ASN1_TYPE source_node)
{
ASN1_TYPE dest_node, p_s, p_d, p_d_prev;
int move;
if (p_s->name)
_asn1_set_name (p_d, p_s->name);
if (p_s->value)
- _asn1_set_value (p_d, p_s->value, p_s->value_len);
+ _asn1_set_value (p_d, p_s->value, p_s->value_len);
move = DOWN;
}
else
static ASN1_TYPE
-_asn1_copy_structure2 (ASN1_TYPE root, const char *source_name)
+_asn1_copy_structure2 (ASN1_TYPE root, const char *source_name)
{
ASN1_TYPE source_node;
}
-asn1_retCode
-_asn1_type_choice_config (ASN1_TYPE node)
+static asn1_retCode
+_asn1_type_choice_config (ASN1_TYPE node)
{
ASN1_TYPE p, p2, p3, p4;
int move, tlen;
}
-asn1_retCode
-_asn1_expand_identifier (ASN1_TYPE * node, ASN1_TYPE root)
+static asn1_retCode
+_asn1_expand_identifier (ASN1_TYPE * node, ASN1_TYPE root)
{
ASN1_TYPE p, p2, p3;
char name2[ASN1_MAX_NAME_SIZE + 2];
#ifndef _STRUCTURE_H
#define _STRUCTURE_H
-asn1_retCode _asn1_create_static_structure(ASN1_TYPE pointer,
- char* output_file_name,char *vector_name);
+asn1_retCode _asn1_create_static_structure (ASN1_TYPE pointer,
+ char *output_file_name,
+ char *vector_name);
-ASN1_TYPE _asn1_copy_structure3(ASN1_TYPE source_node);
+ASN1_TYPE _asn1_copy_structure3 (ASN1_TYPE source_node);
-ASN1_TYPE _asn1_add_node_only(unsigned int type);
+ASN1_TYPE _asn1_add_node_only (unsigned int type);
-ASN1_TYPE _asn1_find_left(ASN1_TYPE node);
+ASN1_TYPE _asn1_find_left (ASN1_TYPE node);
#endif
-
projects / thirdparty / gnutls.git / commitdiff
