*/
static int cert_get_issuer_dn(gnutls_pcert_st * cert, gnutls_datum_t * odn)
{
- ASN1_TYPE dn;
+ asn1_node dn;
int len, result;
int start, end;
const gnutls_datum_t * pkcs3_params,
gnutls_x509_crt_fmt_t format)
{
- ASN1_TYPE c2;
+ asn1_node c2;
int result, need_free = 0;
unsigned int q_bits;
gnutls_datum_t _params;
gnutls_x509_crt_fmt_t format,
gnutls_datum_t * out)
{
- ASN1_TYPE c2;
+ asn1_node c2;
int result;
size_t g_size, p_size;
uint8_t *p_data, *g_data;
#endif
/* created by asn1c */
-extern const ASN1_ARRAY_TYPE gnutls_asn1_tab[];
-extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
+extern const asn1_static_node gnutls_asn1_tab[];
+extern const asn1_static_node pkix_asn1_tab[];
void *_gnutls_file_mutex;
void *_gnutls_pkcs11_mutex;
-ASN1_TYPE _gnutls_pkix1_asn = ASN1_TYPE_EMPTY;
-ASN1_TYPE _gnutls_gnutls_asn = ASN1_TYPE_EMPTY;
+asn1_node _gnutls_pkix1_asn = NULL;
+asn1_node _gnutls_gnutls_asn = NULL;
gnutls_log_func _gnutls_log_func = NULL;
gnutls_audit_log_func _gnutls_audit_log_func = NULL;
goto out;
}
- _gnutls_pkix1_asn = ASN1_TYPE_EMPTY;
+ _gnutls_pkix1_asn = NULL;
res = asn1_array2tree(pkix_asn1_tab, &_gnutls_pkix1_asn, NULL);
if (res != ASN1_SUCCESS) {
gnutls_assert();
int gnutls_is_secure_memory(const void *mem);
-extern ASN1_TYPE _gnutls_pkix1_asn;
-extern ASN1_TYPE _gnutls_gnutls_asn;
+extern asn1_node _gnutls_pkix1_asn;
+extern asn1_node _gnutls_gnutls_asn;
-/* removed const from node_asn* to
+/* removed const from asn1_node* to
* prevent warnings, since libtasn1 doesn't
* use the const keyword in its functions.
*/
-#define _gnutls_get_gnutls_asn() ((ASN1_TYPE) _gnutls_gnutls_asn)
-#define _gnutls_get_pkix() ((ASN1_TYPE) _gnutls_pkix1_asn)
+#define _gnutls_get_gnutls_asn() ((asn1_node) _gnutls_gnutls_asn)
+#define _gnutls_get_pkix() ((asn1_node) _gnutls_pkix1_asn)
extern gnutls_log_func _gnutls_log_func;
extern gnutls_audit_log_func _gnutls_audit_log_func;
* steps.
*/
static int
-__gnutls_x509_read_int(ASN1_TYPE node, const char *value,
+__gnutls_x509_read_int(asn1_node node, const char *value,
bigint_t * ret_mpi, unsigned int flags)
{
int result;
}
int
-_gnutls_x509_read_int(ASN1_TYPE node, const char *value,
+_gnutls_x509_read_int(asn1_node node, const char *value,
bigint_t * ret_mpi)
{
return __gnutls_x509_read_int(node, value, ret_mpi,
}
int
-_gnutls_x509_read_key_int(ASN1_TYPE node, const char *value,
+_gnutls_x509_read_key_int(asn1_node node, const char *value,
bigint_t * ret_mpi)
{
return __gnutls_x509_read_int(node, value, ret_mpi,
}
int
-_gnutls_x509_read_key_int_le(ASN1_TYPE node, const char *value,
+_gnutls_x509_read_key_int_le(asn1_node node, const char *value,
bigint_t * ret_mpi)
{
return __gnutls_x509_read_int(node, value, ret_mpi,
/* Writes the specified integer into the specified node.
*/
static int
-__gnutls_x509_write_int(ASN1_TYPE node, const char *value, bigint_t mpi,
+__gnutls_x509_write_int(asn1_node node, const char *value, bigint_t mpi,
unsigned int flags)
{
uint8_t *tmpstr;
}
int
-_gnutls_x509_write_int(ASN1_TYPE node, const char *value, bigint_t mpi,
+_gnutls_x509_write_int(asn1_node node, const char *value, bigint_t mpi,
int lz)
{
return __gnutls_x509_write_int(node, value, mpi,
}
int
-_gnutls_x509_write_key_int(ASN1_TYPE node, const char *value, bigint_t mpi,
+_gnutls_x509_write_key_int(asn1_node node, const char *value, bigint_t mpi,
int lz)
{
return __gnutls_x509_write_int(node, value, mpi,
}
int
-_gnutls_x509_write_key_int_le(ASN1_TYPE node, const char *value, bigint_t mpi)
+_gnutls_x509_write_key_int_le(asn1_node node, const char *value, bigint_t mpi)
{
return __gnutls_x509_write_int(node, value, mpi,
GNUTLS_X509_INT_OVERWRITE |
const gnutls_datum_t * r,
const gnutls_datum_t * s)
{
- ASN1_TYPE sig;
+ asn1_node sig;
int result, ret;
uint8_t *tmp = NULL;
int
_gnutls_encode_ber_rs(gnutls_datum_t * sig_value, bigint_t r, bigint_t s)
{
- ASN1_TYPE sig;
+ asn1_node sig;
int result;
if ((result =
_gnutls_decode_ber_rs(const gnutls_datum_t * sig_value, bigint_t * r,
bigint_t * s)
{
- ASN1_TYPE sig;
+ asn1_node sig;
int result;
if ((result =
_gnutls_decode_ber_rs_raw(const gnutls_datum_t * sig_value, gnutls_datum_t *r,
gnutls_datum_t *s)
{
- ASN1_TYPE sig;
+ asn1_node sig;
int result;
if ((result =
const gnutls_datum_t * digest,
gnutls_datum_t * output)
{
- ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
+ asn1_node dinfo = NULL;
int result;
const char *algo;
uint8_t *tmp_output;
gnutls_digest_algorithm_t * hash,
unsigned char * digest, unsigned int *digest_size)
{
- ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
+ asn1_node dinfo = NULL;
int result;
char str[MAX(MAX_OID_SIZE, MAX_HASH_SIZE)];
int len;
gnutls_ecc_curve_t *outcurve)
{
gnutls_ecc_curve_t curve = GNUTLS_ECC_CURVE_INVALID;
- ASN1_TYPE asn1 = ASN1_TYPE_EMPTY;
+ asn1_node asn1 = NULL;
unsigned int etype = ASN1_ETYPE_INVALID;
char str[MAX_OID_SIZE];
int str_size;
size_t * output_data_size)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
if (key == NULL) {
gnutls_assert();
gnutls_x509_crt_fmt_t format, gnutls_datum_t * out)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
if (key == NULL) {
gnutls_assert();
{
int result = 0, need_free = 0;
gnutls_datum_t _data;
- ASN1_TYPE spk;
+ asn1_node spk;
if (key == NULL) {
gnutls_assert();
gnutls_datum_t kek;
gnutls_datum_t enc, imit;
gnutls_digest_algorithm_t digalg;
- ASN1_TYPE kx;
+ asn1_node kx;
if (pub->algo == GNUTLS_PK_GOST_01)
digalg = GNUTLS_DIG_GOSTR_94;
gnutls_datum_t *out)
{
int ret;
- ASN1_TYPE kx;
+ asn1_node kx;
gnutls_pk_params_st pub;
gnutls_datum_t kek;
gnutls_datum_t ukm2, enc, imit;
* index here starts from one.
*/
static int
-overwrite_attribute(ASN1_TYPE asn, const char *root, unsigned indx,
+overwrite_attribute(asn1_node asn, const char *root, unsigned indx,
const gnutls_datum_t * ext_data)
{
char name[MAX_NAME_SIZE], name2[MAX_NAME_SIZE];
*
*/
int
-_x509_parse_attribute(ASN1_TYPE asn1_struct,
+_x509_parse_attribute(asn1_node asn1_struct,
const char *attr_name, const char *given_oid, unsigned indx,
int raw, gnutls_datum_t * out)
{
* Critical will be either 0 or 1.
*/
static int
-add_attribute(ASN1_TYPE asn, const char *root, const char *attribute_id,
+add_attribute(asn1_node asn, const char *root, const char *attribute_id,
const gnutls_datum_t * ext_data)
{
int result;
int
-_x509_set_attribute(ASN1_TYPE asn, const char *root,
+_x509_set_attribute(asn1_node asn, const char *root,
const char *ext_id, const gnutls_datum_t * ext_data)
{
int result;
#define GNUTLS_LIB_X509_ATTRIBUTES_H
int
-_x509_parse_attribute(ASN1_TYPE asn1_struct,
+_x509_parse_attribute(asn1_node asn1_struct,
const char *attr_name, const char *given_oid, unsigned indx,
int raw, gnutls_datum_t * out);
int
-_x509_set_attribute(ASN1_TYPE asn, const char *root,
+_x509_set_attribute(asn1_node asn, const char *root,
const char *ext_id, const gnutls_datum_t * ext_data);
#endif /* GNUTLS_LIB_X509_ATTRIBUTES_H */
{
char str[MAX_STRING_LEN], tmpname[128];
int len = -1, result;
- ASN1_TYPE tmpasn = ASN1_TYPE_EMPTY;
+ asn1_node tmpasn = NULL;
char asn1_err[ASN1_MAX_ERROR_DESCRIPTION_SIZE] = "";
unsigned int etype;
gnutls_datum_t td = {NULL, 0};
* to PEM or DER raw data.
*/
int
-_gnutls_x509_export_int_named(ASN1_TYPE asn1_data, const char *name,
+_gnutls_x509_export_int_named(asn1_node asn1_data, const char *name,
gnutls_x509_crt_fmt_t format,
const char *pem_header,
unsigned char *output_data,
* to PEM or DER raw data.
*/
int
-_gnutls_x509_export_int_named2(ASN1_TYPE asn1_data, const char *name,
+_gnutls_x509_export_int_named2(asn1_node asn1_data, const char *name,
gnutls_x509_crt_fmt_t format,
const char *pem_header,
gnutls_datum_t * out)
* the required data size (and places a null byte).
*/
static int
-x509_read_value(ASN1_TYPE c, const char *root,
+x509_read_value(asn1_node c, const char *root,
gnutls_datum_t * ret, unsigned allow_null)
{
int len = 0, result;
}
int
-_gnutls_x509_read_value(ASN1_TYPE c, const char *root,
+_gnutls_x509_read_value(asn1_node c, const char *root,
gnutls_datum_t * ret)
{
return x509_read_value(c, root, ret, 0);
}
int
-_gnutls_x509_read_null_value(ASN1_TYPE c, const char *root,
+_gnutls_x509_read_null_value(asn1_node c, const char *root,
gnutls_datum_t * ret)
{
return x509_read_value(c, root, ret, 1);
* at the end of a readable string value (which is not accounted into size)
*/
int
-_gnutls_x509_read_string(ASN1_TYPE c, const char *root,
+_gnutls_x509_read_string(asn1_node c, const char *root,
gnutls_datum_t * ret, unsigned int etype, unsigned int allow_ber)
{
int len = 0, result;
return 0;
}
-/* DER Encodes the src ASN1_TYPE and stores it to
+/* DER Encodes the src asn1_node and stores it to
* the given datum. If str is non zero then the data are encoded as
* an OCTET STRING.
*/
int
-_gnutls_x509_der_encode(ASN1_TYPE src, const char *src_name,
+_gnutls_x509_der_encode(asn1_node src, const char *src_name,
gnutls_datum_t * res, int str)
{
int size, result;
int asize;
uint8_t *data = NULL;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
size = 0;
result = asn1_der_coding(src, src_name, NULL, &size, NULL);
}
-/* DER Encodes the src ASN1_TYPE and stores it to
+/* DER Encodes the src asn1_node and stores it to
* dest in dest_name. Useful to encode something and store it
* as OCTET. If str is non null then the data are encoded as
* an OCTET STRING.
*/
int
-_gnutls_x509_der_encode_and_copy(ASN1_TYPE src, const char *src_name,
- ASN1_TYPE dest, const char *dest_name,
+_gnutls_x509_der_encode_and_copy(asn1_node src, const char *src_name,
+ asn1_node dest, const char *dest_name,
int str)
{
int result;
return 0;
}
-/* Writes the value of the datum in the given ASN1_TYPE.
+/* Writes the value of the datum in the given asn1_node.
*/
int
-_gnutls_x509_write_value(ASN1_TYPE c, const char *root,
+_gnutls_x509_write_value(asn1_node c, const char *root,
const gnutls_datum_t * data)
{
int ret;
return 0;
}
-/* Writes the value of the datum in the given ASN1_TYPE as a string.
+/* Writes the value of the datum in the given asn1_node as a string.
*/
int
-_gnutls_x509_write_string(ASN1_TYPE c, const char *root,
+_gnutls_x509_write_string(asn1_node c, const char *root,
const gnutls_datum_t * data, unsigned int etype)
{
int ret;
*
*/
int
-_gnutls_x509_encode_and_copy_PKI_params(ASN1_TYPE dst,
+_gnutls_x509_encode_and_copy_PKI_params(asn1_node dst,
const char *dst_name,
const gnutls_pk_params_st * params)
{
const gnutls_pk_params_st * params)
{
int ret;
- ASN1_TYPE tmp;
+ asn1_node tmp;
ret = asn1_create_element(_gnutls_get_pkix(),
"PKIX1.Certificate", &tmp);
* ASN.1 structure. src_name should be something like "tbsCertificate.subjectPublicKeyInfo".
*/
int
-_gnutls_x509_get_pk_algorithm(ASN1_TYPE src, const char *src_name,
+_gnutls_x509_get_pk_algorithm(asn1_node src, const char *src_name,
gnutls_ecc_curve_t *curve,
unsigned int *bits)
{
* returns them into signed_data.
*/
int
-_gnutls_x509_get_signed_data(ASN1_TYPE src, const gnutls_datum_t *der,
+_gnutls_x509_get_signed_data(asn1_node src, const gnutls_datum_t *der,
const char *src_name,
gnutls_datum_t * signed_data)
{
/*-
* gnutls_x509_get_signature_algorithm:
- * @src: should contain an ASN1_TYPE structure
+ * @src: should contain an asn1_node structure
* @src_name: the description of the signature field
*
* This function will return a value of the #gnutls_sign_algorithm_t
* error.
-*/
int
-_gnutls_x509_get_signature_algorithm(ASN1_TYPE src, const char *src_name)
+_gnutls_x509_get_signature_algorithm(asn1_node src, const char *src_name)
{
int result;
char name[128];
* returns them into signed_data.
*/
int
-_gnutls_x509_get_signature(ASN1_TYPE src, const char *src_name,
+_gnutls_x509_get_signature(asn1_node src, const char *src_name,
gnutls_datum_t * signature)
{
int result, len;
return 0;
}
-static int write_complex_string(ASN1_TYPE asn_struct, const char *where,
+static int write_complex_string(asn1_node asn_struct, const char *where,
const struct oid_to_string *oentry,
const uint8_t * data, size_t data_size)
{
char tmp[128];
- ASN1_TYPE c2;
+ asn1_node c2;
int result;
const char *string_type;
unsigned int i;
*/
int
_gnutls_x509_encode_and_write_attribute(const char *given_oid,
- ASN1_TYPE asn1_struct,
+ asn1_node asn1_struct,
const char *where,
const void *_data,
int data_size, int multi)
}
int
-_gnutls_x509_get_raw_field2(ASN1_TYPE c2, const gnutls_datum_t * raw,
+_gnutls_x509_get_raw_field2(asn1_node c2, const gnutls_datum_t * raw,
const char *whom, gnutls_datum_t * dn)
{
int result, len1;
return gnutls_assert_val(GNUTLS_GOST_PARAMSET_UNKNOWN);
}
-int _gnutls_x509_get_version(ASN1_TYPE root, const char *name)
+int _gnutls_x509_get_version(asn1_node root, const char *name)
{
uint8_t version[8];
int len, result;
const struct oid_to_string *_gnutls_oid_get_entry(const struct oid_to_string *ots, const char *oid);
-int _gnutls_x509_set_time(ASN1_TYPE c2, const char *where, time_t tim,
+int _gnutls_x509_set_time(asn1_node c2, const char *where, time_t tim,
int force_general);
int
-_gnutls_x509_set_raw_time(ASN1_TYPE c2, const char *where, time_t tim);
+_gnutls_x509_set_raw_time(asn1_node c2, const char *where, time_t tim);
int _gnutls_x509_decode_string(unsigned int etype,
const uint8_t * der, size_t der_size,
int value_size, gnutls_datum_t * out);
const char *_gnutls_ldap_string_to_oid(const char *str, unsigned str_len);
-time_t _gnutls_x509_get_time(ASN1_TYPE c2, const char *when, int general);
+time_t _gnutls_x509_get_time(asn1_node c2, const char *when, int general);
gnutls_x509_subject_alt_name_t _gnutls_x509_san_find_type(char *str_type);
-int _gnutls_x509_der_encode_and_copy(ASN1_TYPE src, const char *src_name,
- ASN1_TYPE dest, const char *dest_name,
+int _gnutls_x509_der_encode_and_copy(asn1_node src, const char *src_name,
+ asn1_node dest, const char *dest_name,
int str);
-int _gnutls_x509_der_encode(ASN1_TYPE src, const char *src_name,
+int _gnutls_x509_der_encode(asn1_node src, const char *src_name,
gnutls_datum_t * res, int str);
#define _gnutls_x509_export_int(asn1, format, header, out, out_size) \
_gnutls_x509_export_int_named(asn1, "", format, header, out, out_size)
-int _gnutls_x509_export_int_named(ASN1_TYPE asn1_data, const char *name,
+int _gnutls_x509_export_int_named(asn1_node asn1_data, const char *name,
gnutls_x509_crt_fmt_t format,
const char *pem_header,
unsigned char *output_data,
#define _gnutls_x509_export_int2(asn1, format, header, out) \
_gnutls_x509_export_int_named2(asn1, "", format, header, out)
-int _gnutls_x509_export_int_named2(ASN1_TYPE asn1_data, const char *name,
+int _gnutls_x509_export_int_named2(asn1_node asn1_data, const char *name,
gnutls_x509_crt_fmt_t format,
const char *pem_header,
gnutls_datum_t * out);
-int _gnutls_x509_read_value(ASN1_TYPE c, const char *root,
+int _gnutls_x509_read_value(asn1_node c, const char *root,
gnutls_datum_t * ret);
-int _gnutls_x509_read_null_value(ASN1_TYPE c, const char *root,
+int _gnutls_x509_read_null_value(asn1_node c, const char *root,
gnutls_datum_t * ret);
-int _gnutls_x509_read_string(ASN1_TYPE c, const char *root,
+int _gnutls_x509_read_string(asn1_node c, const char *root,
gnutls_datum_t * ret, unsigned int etype,
unsigned allow_ber);
-int _gnutls_x509_write_value(ASN1_TYPE c, const char *root,
+int _gnutls_x509_write_value(asn1_node c, const char *root,
const gnutls_datum_t * data);
-int _gnutls_x509_write_string(ASN1_TYPE c, const char *root,
+int _gnutls_x509_write_string(asn1_node c, const char *root,
const gnutls_datum_t * data,
unsigned int etype);
int _gnutls_x509_encode_and_write_attribute(const char *given_oid,
- ASN1_TYPE asn1_struct,
+ asn1_node asn1_struct,
const char *where,
const void *data,
int sizeof_data, int multi);
-int _gnutls_x509_decode_and_read_attribute(ASN1_TYPE asn1_struct,
+int _gnutls_x509_decode_and_read_attribute(asn1_node asn1_struct,
const char *where, char *oid,
int oid_size,
gnutls_datum_t * value,
int multi, int octet);
-int _gnutls_x509_get_pk_algorithm(ASN1_TYPE src, const char *src_name,
+int _gnutls_x509_get_pk_algorithm(asn1_node src, const char *src_name,
gnutls_ecc_curve_t *curve,
unsigned int *bits);
int
-_gnutls_x509_get_signature_algorithm(ASN1_TYPE src, const char *src_name);
+_gnutls_x509_get_signature_algorithm(asn1_node src, const char *src_name);
-int _gnutls_x509_encode_and_copy_PKI_params(ASN1_TYPE dst,
+int _gnutls_x509_encode_and_copy_PKI_params(asn1_node dst,
const char *dst_name,
const gnutls_pk_params_st * params);
int _gnutls_x509_encode_PKI_params(gnutls_datum_t * der,
const gnutls_pk_params_st * params);
-int _gnutls_asn1_copy_node(ASN1_TYPE * dst, const char *dst_name,
- ASN1_TYPE src, const char *src_name);
+int _gnutls_asn1_copy_node(asn1_node * dst, const char *dst_name,
+ asn1_node src, const char *src_name);
-int _gnutls_x509_get_signed_data(ASN1_TYPE src, const gnutls_datum_t *der,
+int _gnutls_x509_get_signed_data(asn1_node src, const gnutls_datum_t *der,
const char *src_name,
gnutls_datum_t * signed_data);
-int _gnutls_x509_get_signature(ASN1_TYPE src, const char *src_name,
+int _gnutls_x509_get_signature(asn1_node src, const char *src_name,
gnutls_datum_t * signature);
-int _gnutls_get_asn_mpis(ASN1_TYPE asn, const char *root,
+int _gnutls_get_asn_mpis(asn1_node asn, const char *root,
gnutls_pk_params_st * params);
int _gnutls_get_key_id(gnutls_pk_params_st *,
/* Given a @c2 which it returns an allocated DER encoding of @whom in @out */
inline static int
-_gnutls_x509_get_raw_field(ASN1_TYPE c2, const char *whom, gnutls_datum_t *out)
+_gnutls_x509_get_raw_field(asn1_node c2, const char *whom, gnutls_datum_t *out)
{
return _gnutls_x509_der_encode(c2, whom, out, 0);
}
int
-_gnutls_x509_get_raw_field2(ASN1_TYPE c2, const gnutls_datum_t * raw,
+_gnutls_x509_get_raw_field2(asn1_node c2, const gnutls_datum_t * raw,
const char *whom, gnutls_datum_t * dn);
unsigned
time_t _gnutls_x509_generalTime2gtime(const char *ttime);
-int _gnutls_get_extension(ASN1_TYPE asn, const char *root,
+int _gnutls_get_extension(asn1_node asn, const char *root,
const char *extension_id, int indx,
gnutls_datum_t * ret, unsigned int *_critical);
-int _gnutls_set_extension(ASN1_TYPE asn, const char *root,
+int _gnutls_set_extension(asn1_node asn, const char *root,
const char *ext_id,
const gnutls_datum_t * ext_data, unsigned int critical);
int _gnutls_x509_raw_crt_to_raw_pubkey(const gnutls_datum_t * cert,
gnutls_datum_t * rpubkey);
-int _gnutls_x509_get_version(ASN1_TYPE root, const char *name);
+int _gnutls_x509_get_version(asn1_node root, const char *name);
int x509_crt_to_raw_pubkey(gnutls_x509_crt_t crt,
gnutls_datum_t * rpubkey);
}
static int
-_get_authority_key_id(gnutls_x509_crl_t cert, ASN1_TYPE * c2,
+_get_authority_key_id(gnutls_x509_crl_t cert, asn1_node * c2,
unsigned int *critical)
{
int ret;
gnutls_datum_t id;
- *c2 = ASN1_TYPE_EMPTY;
+ *c2 = NULL;
if (cert == NULL) {
gnutls_assert();
unsigned int *critical)
{
int ret, result, len;
- ASN1_TYPE c2;
+ asn1_node c2;
ret = _get_authority_key_id(crl, &c2, critical);
if (ret < 0)
unsigned int *critical)
{
int result, len, ret;
- ASN1_TYPE c2;
+ asn1_node c2;
ret = _get_authority_key_id(crl, &c2, critical);
if (ret < 0)
unsigned int *critical)
{
int result, ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
uint8_t buf[128];
size_t buf_size = sizeof(buf);
char name[MAX_NAME_SIZE];
char *extensions = NULL;
size_t extensions_size = 0;
- ASN1_TYPE c2;
+ asn1_node c2;
int len;
if (!crq) {
char name[MAX_NAME_SIZE];
unsigned char *extensions = NULL;
size_t extensions_size = 0;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
if (!crq) {
gnutls_assert();
unsigned int *critical, int othername_oid)
{
int result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
gnutls_x509_subject_alt_name_t type;
gnutls_datum_t dnsname = { NULL, 0 };
size_t dns_size = 0;
char tmpstr[MAX_NAME_SIZE];
int result, len;
gnutls_datum_t prev = { NULL, 0 };
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
size_t prev_size = 0;
if (oid)
{
int result;
gnutls_datum_t prev = { NULL, 0 }, der_data;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
size_t prev_size = 0;
/* Read existing extension, if there is one.
{
int result;
gnutls_datum_t der_data;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
if (crq == NULL) {
gnutls_assert();
* Name (you need a parser just to read a name in the X.509 protocols!!!)
*/
-static int append_elements(ASN1_TYPE asn1_struct, const char *asn1_rdn_name, gnutls_buffer_st *str, int k1, unsigned last)
+static int append_elements(asn1_node asn1_struct, const char *asn1_rdn_name, gnutls_buffer_st *str, int k1, unsigned last)
{
int k2, result, max_k2;
int len;
}
int
-_gnutls_x509_get_dn(ASN1_TYPE asn1_struct,
+_gnutls_x509_get_dn(asn1_node asn1_struct,
const char *asn1_rdn_name, gnutls_datum_t * dn,
unsigned flags)
{
* That is to point in the rndSequence.
*/
int
-_gnutls_x509_parse_dn(ASN1_TYPE asn1_struct,
+_gnutls_x509_parse_dn(asn1_node asn1_struct,
const char *asn1_rdn_name, char *buf,
size_t * buf_size, unsigned flags)
{
* OID found, 1 the second etc.
*/
int
-_gnutls_x509_parse_dn_oid(ASN1_TYPE asn1_struct,
+_gnutls_x509_parse_dn_oid(asn1_node asn1_struct,
const char *asn1_rdn_name,
const char *given_oid, int indx,
unsigned int raw_flag, gnutls_datum_t * out)
* OID found, 1 the second etc.
*/
int
-_gnutls_x509_get_dn_oid(ASN1_TYPE asn1_struct,
+_gnutls_x509_get_dn_oid(asn1_node asn1_struct,
const char *asn1_rdn_name,
int indx, void *_oid, size_t * sizeof_oid)
{
*/
static int
_gnutls_x509_write_attribute(const char *given_oid,
- ASN1_TYPE asn1_struct, const char *where,
+ asn1_node asn1_struct, const char *where,
const void *_data, int sizeof_data)
{
char tmp[128];
* The output is allocated and stored in value.
*/
int
-_gnutls_x509_decode_and_read_attribute(ASN1_TYPE asn1_struct,
+_gnutls_x509_decode_and_read_attribute(asn1_node asn1_struct,
const char *where, char *oid,
int oid_size,
gnutls_datum_t * value, int multi,
*
*/
int
-_gnutls_x509_set_dn_oid(ASN1_TYPE asn1_struct,
+_gnutls_x509_set_dn_oid(asn1_node asn1_struct,
const char *asn1_name, const char *given_oid,
int raw_flag, const char *name, int sizeof_name)
{
void *buf, size_t * buf_size)
{
int result;
- ASN1_TYPE dn = ASN1_TYPE_EMPTY;
+ asn1_node dn = NULL;
gnutls_datum_t td;
if (buf_size == 0) {
unsigned indx, void *buf, size_t * buf_size)
{
int result;
- ASN1_TYPE dn = ASN1_TYPE_EMPTY;
+ asn1_node dn = NULL;
if (buf_size == 0) {
return GNUTLS_E_INVALID_REQUEST;
#include <datum.h>
int
-_gnutls_get_extension(ASN1_TYPE asn, const char *root,
+_gnutls_get_extension(asn1_node asn, const char *root,
const char *extension_id, int indx,
gnutls_datum_t * ret, unsigned int *_critical)
{
}
static int
-get_indx_extension(ASN1_TYPE asn, const char *root,
+get_indx_extension(asn1_node asn, const char *root,
int indx, gnutls_datum_t * out)
{
char name[MAX_NAME_SIZE];
* If you have passed the last extension, GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will
* be returned.
*/
-static int get_extension_oid(ASN1_TYPE asn, const char *root,
+static int get_extension_oid(asn1_node asn, const char *root,
unsigned indx, void *oid, size_t * sizeof_oid)
{
int k, result, len;
* Critical will be either 0 or 1.
*/
static int
-add_extension(ASN1_TYPE asn, const char *root, const char *extension_id,
+add_extension(asn1_node asn, const char *root, const char *extension_id,
const gnutls_datum_t * ext_data, unsigned int critical)
{
int result;
* index here starts from one.
*/
static int
-overwrite_extension(ASN1_TYPE asn, const char *root, unsigned int indx,
+overwrite_extension(asn1_node asn, const char *root, unsigned int indx,
const gnutls_datum_t * ext_data, unsigned int critical)
{
char name[MAX_NAME_SIZE], name2[MAX_NAME_SIZE];
}
int
-_gnutls_set_extension(ASN1_TYPE asn, const char *root,
+_gnutls_set_extension(asn1_node asn, const char *root,
const char *ext_id,
const gnutls_datum_t * ext_data, unsigned int critical)
{
unsigned char *extensions = NULL;
size_t extensions_size = 0;
gnutls_datum_t der;
- ASN1_TYPE c2;
+ asn1_node c2;
int result;
result =
size_t * _nr_size,
uint8_t * extnValue, int extnValueLen)
{
- ASN1_TYPE ext = ASN1_TYPE_EMPTY;
+ asn1_node ext = NULL;
int result;
int nr_size = *_nr_size;
_gnutls_x509_ext_gen_number(const uint8_t * number, size_t nr_size,
gnutls_datum_t * der_ext)
{
- ASN1_TYPE ext = ASN1_TYPE_EMPTY;
+ asn1_node ext = NULL;
int result;
result =
}
int
-_gnutls_write_general_name(ASN1_TYPE ext, const char *ext_name,
+_gnutls_write_general_name(asn1_node ext, const char *ext_name,
gnutls_x509_subject_alt_name_t type,
const void *data, unsigned int data_size)
{
}
int
-_gnutls_write_new_general_name(ASN1_TYPE ext, const char *ext_name,
+_gnutls_write_new_general_name(asn1_node ext, const char *ext_name,
gnutls_x509_subject_alt_name_t type,
const void *data, unsigned int data_size)
{
}
int
-_gnutls_write_new_othername(ASN1_TYPE ext, const char *ext_name,
+_gnutls_write_new_othername(asn1_node ext, const char *ext_name,
const char *oid,
const void *data, unsigned int data_size)
{
gnutls_pk_params_st * params)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
if ((result = asn1_create_element
(_gnutls_get_gnutls_asn(), "GNUTLS.RSAPublicKey", &spk))
gnutls_pk_params_st * params)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
if ((result = asn1_create_element
(_gnutls_get_pkix(), "PKIX1.Dss-Parms",
unsigned int * curve)
{
int ret;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
char oid[MAX_OID_SIZE];
int oid_size;
gnutls_x509_spki_st * params)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
+ asn1_node c2 = NULL;
gnutls_digest_algorithm_t digest;
char oid[MAX_OID_SIZE] = "";
int size;
gnutls_pk_algorithm_t algo)
{
int ret;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
char oid[MAX_OID_SIZE];
int oid_size;
gnutls_ecc_curve_t curve;
gnutls_datum_t * der)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
der->data = NULL;
der->size = 0;
gnutls_datum_t * der)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
der->data = NULL;
der->size = 0;
gnutls_datum_t * der)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
const char *oid;
der->data = NULL;
gnutls_datum_t *der)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
+ asn1_node c2 = NULL;
const char *oid;
gnutls_datum_t tmp = { NULL, 0 };
gnutls_datum_t * der)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
const char *oid;
der->data = NULL;
gnutls_datum_t * der)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
der->data = NULL;
der->size = 0;
/* Encodes the RSA parameters into an ASN.1 RSA private key structure.
*/
static int
-_gnutls_asn1_encode_rsa(ASN1_TYPE * c2, gnutls_pk_params_st * params)
+_gnutls_asn1_encode_rsa(asn1_node * c2, gnutls_pk_params_st * params)
{
int result, ret;
uint8_t null = '\0';
*/
/* first make sure that no previously allocated data are leaked */
- if (*c2 != ASN1_TYPE_EMPTY) {
+ if (*c2 != NULL) {
asn1_delete_structure(c2);
- *c2 = ASN1_TYPE_EMPTY;
+ *c2 = NULL;
}
if ((result = asn1_create_element
/* Encodes the ECC parameters into an ASN.1 ECPrivateKey structure.
*/
static int
-_gnutls_asn1_encode_ecc(ASN1_TYPE * c2, gnutls_pk_params_st * params)
+_gnutls_asn1_encode_ecc(asn1_node * c2, gnutls_pk_params_st * params)
{
int ret;
uint8_t one = '\x01';
return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
/* first make sure that no previously allocated data are leaked */
- if (*c2 != ASN1_TYPE_EMPTY) {
+ if (*c2 != NULL) {
asn1_delete_structure(c2);
- *c2 = ASN1_TYPE_EMPTY;
+ *c2 = NULL;
}
if ((ret = asn1_create_element
}
static int
-_gnutls_asn1_encode_gost(ASN1_TYPE * c2, gnutls_pk_params_st * params)
+_gnutls_asn1_encode_gost(asn1_node * c2, gnutls_pk_params_st * params)
{
int ret;
const char *oid;
return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
/* first make sure that no previously allocated data are leaked */
- if (*c2 != ASN1_TYPE_EMPTY) {
+ if (*c2 != NULL) {
asn1_delete_structure(c2);
- *c2 = ASN1_TYPE_EMPTY;
+ *c2 = NULL;
}
if ((ret = asn1_create_element
/* Encodes the DSA parameters into an ASN.1 DSAPrivateKey structure.
*/
static int
-_gnutls_asn1_encode_dsa(ASN1_TYPE * c2, gnutls_pk_params_st * params)
+_gnutls_asn1_encode_dsa(asn1_node * c2, gnutls_pk_params_st * params)
{
int result, ret;
const uint8_t null = '\0';
/* first make sure that no previously allocated data are leaked */
- if (*c2 != ASN1_TYPE_EMPTY) {
+ if (*c2 != NULL) {
asn1_delete_structure(c2);
- *c2 = ASN1_TYPE_EMPTY;
+ *c2 = NULL;
}
if ((result = asn1_create_element
return ret;
}
-int _gnutls_asn1_encode_privkey(ASN1_TYPE * c2,
+int _gnutls_asn1_encode_privkey(asn1_node * c2,
gnutls_pk_params_st * params)
{
switch (params->algo) {
int _gnutls_krb5_principal_to_der(const char *name, gnutls_datum_t * der)
{
int ret, result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
krb5_principal_data *princ;
unsigned i;
return ret;
}
-static int principal_to_str(ASN1_TYPE c2, gnutls_buffer_st * str)
+static int principal_to_str(asn1_node c2, gnutls_buffer_st * str)
{
gnutls_datum_t realm = { NULL, 0 };
gnutls_datum_t component = { NULL, 0 };
gnutls_datum_t * name)
{
int ret, result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
gnutls_buffer_st str;
_gnutls_buffer_init(&str);
int _gnutls_x509_read_der_int(uint8_t * der, int dersize, bigint_t * out)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
/* == INTEGER */
if ((result = asn1_create_element
int _gnutls_x509_read_der_uint(uint8_t * der, int dersize, unsigned int *out)
{
int result;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
/* == INTEGER */
if ((result = asn1_create_element
/* Extracts DSA and RSA parameters from a certificate.
*/
int
-_gnutls_get_asn_mpis(ASN1_TYPE asn, const char *root,
+_gnutls_get_asn_mpis(asn1_node asn, const char *root,
gnutls_pk_params_st * params)
{
int result;
* This is the "signatureAlgorithm" fields.
*/
int
-_gnutls_x509_read_pkalgo_params(ASN1_TYPE src, const char *src_name,
+_gnutls_x509_read_pkalgo_params(asn1_node src, const char *src_name,
gnutls_x509_spki_st *spki, unsigned is_sig)
{
int result;
return 0;
}
-static int write_oid_and_params(ASN1_TYPE dst, const char *dst_name, const char *oid, gnutls_x509_spki_st *params)
+static int write_oid_and_params(asn1_node dst, const char *dst_name, const char *oid, gnutls_x509_spki_st *params)
{
int result;
char name[128];
}
int
-_gnutls_x509_write_spki_params(ASN1_TYPE dst, const char *dst_name,
+_gnutls_x509_write_spki_params(asn1_node dst, const char *dst_name,
gnutls_x509_spki_st *params)
{
const char *oid;
}
int
-_gnutls_x509_write_sign_params(ASN1_TYPE dst, const char *dst_name,
+_gnutls_x509_write_sign_params(asn1_node dst, const char *dst_name,
const gnutls_sign_entry_st *se, gnutls_x509_spki_st *params)
{
const char *oid;
* steps.
*/
int
-_gnutls_x509_read_uint(ASN1_TYPE node, const char *value,
+_gnutls_x509_read_uint(asn1_node node, const char *value,
unsigned int *ret)
{
int len, result;
/* Writes the specified integer into the specified node.
*/
int
-_gnutls_x509_write_uint32(ASN1_TYPE node, const char *value, uint32_t num)
+_gnutls_x509_write_uint32(asn1_node node, const char *value, uint32_t num)
{
uint8_t tmpstr[5];
int result;
return GNUTLS_E_SUCCESS;
}
-int _gnutls_extract_name_constraints(ASN1_TYPE c2, const char *vstr,
+int _gnutls_extract_name_constraints(asn1_node c2, const char *vstr,
name_constraints_node_st ** _nc)
{
int ret;
#include "intprops.h"
typedef struct gnutls_ocsp_req_int {
- ASN1_TYPE req;
+ asn1_node req;
unsigned init;
} gnutls_ocsp_req_int;
typedef struct gnutls_ocsp_resp_int {
- ASN1_TYPE resp;
+ asn1_node resp;
gnutls_datum_t response_type_oid;
- ASN1_TYPE basicresp;
+ asn1_node basicresp;
gnutls_datum_t der;
unsigned init;
} gnutls_ocsp_resp_int;
static void print_issuer_sign_tool(gnutls_buffer_st * str, const char *prefix, const gnutls_datum_t *der)
{
int ret;
- ASN1_TYPE tmpasn = ASN1_TYPE_EMPTY;
+ asn1_node tmpasn = NULL;
char asn1_err[ASN1_MAX_ERROR_DESCRIPTION_SIZE] = "";
gnutls_datum_t tmp;
/* Decodes the PKCS #12 auth_safe, and returns the allocated raw data,
- * which holds them. Returns an ASN1_TYPE of authenticatedSafe.
+ * which holds them. Returns an asn1_node of authenticatedSafe.
*/
static int
-_decode_pkcs12_auth_safe(ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
+_decode_pkcs12_auth_safe(asn1_node pkcs12, asn1_node * authen_safe,
gnutls_datum_t * raw)
{
char oid[MAX_OID_SIZE];
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
gnutls_datum_t auth_safe = { NULL, 0 };
int len, result;
char error_str[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
gnutls_pkcs12_bag_t bag)
{
char oid[MAX_OID_SIZE], root[MAX_NAME_SIZE];
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int len, result;
int bag_type;
gnutls_datum_t attr_val;
static int
-_parse_safe_contents(ASN1_TYPE sc, const char *sc_name,
+_parse_safe_contents(asn1_node sc, const char *sc_name,
gnutls_pkcs12_bag_t bag)
{
gnutls_datum_t content = { NULL, 0 };
gnutls_pkcs12_get_bag(gnutls_pkcs12_t pkcs12,
int indx, gnutls_pkcs12_bag_t bag)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result, len;
char root2[MAX_NAME_SIZE];
char oid[MAX_OID_SIZE];
/* Creates an empty PFX structure for the PKCS12 structure.
*/
-static int create_empty_pfx(ASN1_TYPE pkcs12)
+static int create_empty_pfx(asn1_node pkcs12)
{
uint8_t three = 3;
int result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
/* Use version 3
*/
**/
int gnutls_pkcs12_set_bag(gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
- ASN1_TYPE safe_cont = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
+ asn1_node safe_cont = NULL;
int result;
int enc = 0, dum = 1;
char null;
static int
write_attributes(gnutls_pkcs12_bag_t bag, int elem,
- ASN1_TYPE c2, const char *where)
+ asn1_node c2, const char *where)
{
int result;
char root[128];
* the given datum. Enc is set to non-zero if the data are encrypted;
*/
int
-_pkcs12_encode_safe_contents(gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
+_pkcs12_encode_safe_contents(gnutls_pkcs12_bag_t bag, asn1_node * contents,
int *enc)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result;
unsigned i;
const char *oid;
const gnutls_datum_t * in, gnutls_datum_t * out)
{
int ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
switch (type) {
case GNUTLS_BAG_CERTIFICATE:
const gnutls_datum_t * raw, gnutls_datum_t * out)
{
int ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
switch (type) {
case GNUTLS_BAG_CERTIFICATE:
unsigned int flags)
{
int ret;
- ASN1_TYPE safe_cont = ASN1_TYPE_EMPTY;
+ asn1_node safe_cont = NULL;
gnutls_datum_t der = { NULL, 0 };
gnutls_datum_t enc = { NULL, 0 };
schema_id id;
int result, len;
char enc_oid[MAX_OID_SIZE];
gnutls_datum_t tmp;
- ASN1_TYPE pasn = ASN1_TYPE_EMPTY, pkcs7_asn = ASN1_TYPE_EMPTY;
+ asn1_node pasn = NULL, pkcs7_asn = NULL;
int params_start, params_end, params_len;
struct pbkdf2_params kdf_params;
struct pbe_enc_params enc_params;
{
int result, len;
char enc_oid[MAX_OID_SIZE];
- ASN1_TYPE pasn = ASN1_TYPE_EMPTY, pkcs7_asn = ASN1_TYPE_EMPTY;
+ asn1_node pasn = NULL, pkcs7_asn = NULL;
int params_start, params_end, params_len;
struct pbe_enc_params enc_params;
schema_id schema;
int result;
gnutls_datum_t key = { NULL, 0 };
gnutls_datum_t tmp = { NULL, 0 };
- ASN1_TYPE pkcs7_asn = ASN1_TYPE_EMPTY;
+ asn1_node pkcs7_asn = NULL;
struct pbkdf2_params kdf_params;
struct pbe_enc_params enc_params;
const struct pkcs_cipher_schema_st *s;
/* Reads the PBKDF2 parameters.
*/
static int
-read_pbkdf2_params(ASN1_TYPE pasn,
+read_pbkdf2_params(asn1_node pasn,
const gnutls_datum_t * der, struct pbkdf2_params *params)
{
int params_start, params_end;
int params_len, len, result;
- ASN1_TYPE pbkdf2_asn = ASN1_TYPE_EMPTY;
+ asn1_node pbkdf2_asn = NULL;
char oid[MAX_OID_SIZE];
memset(params, 0, sizeof(*params));
/* Reads the PBE parameters from PKCS-12 schemas (*&#%*&#% RSA).
*/
-static int read_pkcs12_kdf_params(ASN1_TYPE pasn, struct pbkdf2_params *params)
+static int read_pkcs12_kdf_params(asn1_node pasn, struct pbkdf2_params *params)
{
int result;
/* Writes the PBE parameters for PKCS-12 schemas.
*/
static int
-write_pkcs12_kdf_params(ASN1_TYPE pasn, const struct pbkdf2_params *kdf_params)
+write_pkcs12_kdf_params(asn1_node pasn, const struct pbkdf2_params *kdf_params)
{
int result;
read_pbes2_gost_oid(uint8_t *der, size_t len, char *oid, int oid_size)
{
int result;
- ASN1_TYPE pbe_asn = ASN1_TYPE_EMPTY;
+ asn1_node pbe_asn = NULL;
if ((result =
asn1_create_element(_gnutls_get_pkix(),
}
static int
-read_pbes2_enc_params(ASN1_TYPE pasn,
+read_pbes2_enc_params(asn1_node pasn,
const gnutls_datum_t * der, struct pbe_enc_params *params)
{
int params_start, params_end;
int params_len, len, result;
- ASN1_TYPE pbe_asn = ASN1_TYPE_EMPTY;
+ asn1_node pbe_asn = NULL;
const struct pkcs_cipher_schema_st *p;
memset(params, 0, sizeof(*params));
struct pbkdf2_params *kdf_params,
struct pbe_enc_params *enc_params)
{
- ASN1_TYPE pasn = ASN1_TYPE_EMPTY;
+ asn1_node pasn = NULL;
int result;
gnutls_datum_t tmp;
const struct pkcs_cipher_schema_st *p;
}
int
-_gnutls_pkcs_raw_decrypt_data(schema_id schema, ASN1_TYPE pkcs8_asn,
+_gnutls_pkcs_raw_decrypt_data(schema_id schema, asn1_node pkcs8_asn,
const char *root, const char *_password,
const struct pbkdf2_params *kdf_params,
const struct pbe_enc_params *enc_params,
/* Writes the PBKDF2 parameters.
*/
static int
-write_pbkdf2_params(ASN1_TYPE pasn, const struct pbkdf2_params *kdf_params)
+write_pbkdf2_params(asn1_node pasn, const struct pbkdf2_params *kdf_params)
{
int result;
- ASN1_TYPE pbkdf2_asn = ASN1_TYPE_EMPTY;
+ asn1_node pbkdf2_asn = NULL;
uint8_t tmp[MAX_OID_SIZE];
const mac_entry_st *me;
}
static int
-write_pbes2_enc_params(ASN1_TYPE pasn, const struct pbe_enc_params *params)
+write_pbes2_enc_params(asn1_node pasn, const struct pbe_enc_params *params)
{
int result;
- ASN1_TYPE pbe_asn = ASN1_TYPE_EMPTY;
+ asn1_node pbe_asn = NULL;
const struct pkcs_cipher_schema_st *p;
const char *cipher_oid;
* part.
*/
int
-_gnutls_pkcs_write_schema_params(schema_id schema, ASN1_TYPE pkcs8_asn,
+_gnutls_pkcs_write_schema_params(schema_id schema, asn1_node pkcs8_asn,
const char *where,
const struct pbkdf2_params *kdf_params,
const struct pbe_enc_params *enc_params)
{
int result;
- ASN1_TYPE pasn = ASN1_TYPE_EMPTY;
+ asn1_node pasn = NULL;
const struct pkcs_cipher_schema_st *p;
p = _gnutls_pkcs_schema_get(schema);
static const uint8_t one = 1;
-/* Decodes the PKCS #7 signed data, and returns an ASN1_TYPE,
+/* Decodes the PKCS #7 signed data, and returns an asn1_node,
* which holds them. If raw is non null then the raw decoded
* data are copied (they are locally allocated) there.
*/
static int _decode_pkcs7_signed_data(gnutls_pkcs7_t pkcs7)
{
- ASN1_TYPE c2;
+ asn1_node c2;
int len, result;
gnutls_datum_t tmp = {NULL, 0};
static time_t parse_time(gnutls_pkcs7_t pkcs7, const char *root)
{
char tval[128];
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
time_t ret;
int result, len;
{
int result;
- if (pkcs7->signed_data != ASN1_TYPE_EMPTY) {
+ if (pkcs7->signed_data != NULL) {
disable_opt_fields(pkcs7);
/* Replace the old content with the new
/* Creates an empty signed data structure in the pkcs7
* structure and returns a handle to the signed data.
*/
-static int create_empty_signed_data(ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
+static int create_empty_signed_data(asn1_node pkcs7, asn1_node * sdata)
{
int result;
- *sdata = ASN1_TYPE_EMPTY;
+ *sdata = NULL;
if ((result = asn1_create_element
(_gnutls_get_pkix(), "PKIX1.pkcs-7-SignedData",
/* If the signed data are uninitialized
* then create them.
*/
- if (pkcs7->signed_data == ASN1_TYPE_EMPTY) {
+ if (pkcs7->signed_data == NULL) {
/* The pkcs7 structure is new, so create the
* signedData.
*/
/* If the signed data are uninitialized
* then create them.
*/
- if (pkcs7->signed_data == ASN1_TYPE_EMPTY) {
+ if (pkcs7->signed_data == NULL) {
/* The pkcs7 structure is new, so create the
* signedData.
*/
return result;
}
-static int write_signer_id(ASN1_TYPE c2, const char *root,
+static int write_signer_id(asn1_node c2, const char *root,
gnutls_x509_crt_t signer, unsigned flags)
{
int result;
return 0;
}
-static int add_attrs(ASN1_TYPE c2, const char *root, gnutls_pkcs7_attrs_t attrs,
+static int add_attrs(asn1_node c2, const char *root, gnutls_pkcs7_attrs_t attrs,
unsigned already_set)
{
char name[256];
return 0;
}
-static int write_attributes(ASN1_TYPE c2, const char *root,
+static int write_attributes(asn1_node c2, const char *root,
const gnutls_datum_t * data,
const mac_entry_st * me,
gnutls_pkcs7_attrs_t other_attrs, unsigned flags)
if (pkcs7 == NULL || me == NULL)
return GNUTLS_E_INVALID_REQUEST;
- if (pkcs7->signed_data == ASN1_TYPE_EMPTY) {
+ if (pkcs7->signed_data == NULL) {
result =
asn1_create_element(_gnutls_get_pkix(),
"PKIX1.pkcs-7-SignedData",
int _gnutls_check_pkcs_cipher_schema(const char *oid);
int
-_gnutls_pkcs_raw_decrypt_data(schema_id schema, ASN1_TYPE pkcs8_asn,
+_gnutls_pkcs_raw_decrypt_data(schema_id schema, asn1_node pkcs8_asn,
const char *root, const char *password,
const struct pbkdf2_params *kdf_params,
const struct pbe_enc_params *enc_params,
struct pbe_enc_params *enc_params);
int
-_gnutls_pkcs_write_schema_params(schema_id schema, ASN1_TYPE pkcs8_asn,
+_gnutls_pkcs_write_schema_params(schema_id schema, asn1_node pkcs8_asn,
const char *where,
const struct pbkdf2_params *kdf_params,
const struct pbe_enc_params *enc_params);
*key = gnutls_calloc(1, sizeof(gnutls_x509_privkey_int));
if (*key) {
- (*key)->key = ASN1_TYPE_EMPTY;
+ (*key)->key = NULL;
return 0; /* success */
}
if (key->key)
asn1_delete_structure2(&key->key, ASN1_DELETE_FLAG_ZEROIZE);
- key->key = ASN1_TYPE_EMPTY;
+ key->key = NULL;
}
/**
/* Converts an RSA PKCS#1 key to
* an internal structure (gnutls_private_key)
*/
-ASN1_TYPE
+asn1_node
_gnutls_privkey_decode_pkcs1_rsa_key(const gnutls_datum_t * raw_key,
gnutls_x509_privkey_t pkey)
{
int result;
- ASN1_TYPE pkey_asn;
+ asn1_node pkey_asn;
gnutls_pk_params_init(&pkey->params);
* an internal structure (gnutls_private_key)
*/
int
-_gnutls_privkey_decode_ecc_key(ASN1_TYPE* pkey_asn, const gnutls_datum_t * raw_key,
+_gnutls_privkey_decode_ecc_key(asn1_node* pkey_asn, const gnutls_datum_t * raw_key,
gnutls_x509_privkey_t pkey, gnutls_ecc_curve_t curve)
{
int ret;
}
-static ASN1_TYPE
+static asn1_node
decode_dsa_key(const gnutls_datum_t * raw_key, gnutls_x509_privkey_t pkey)
{
int result;
- ASN1_TYPE dsa_asn;
+ asn1_node dsa_asn;
gnutls_datum_t seed = {NULL,0};
char oid[MAX_OID_SIZE];
int oid_size;
#include "attributes.h"
#include "prov-seed.h"
-static int _decode_pkcs8_ecc_key(ASN1_TYPE pkcs8_asn,
+static int _decode_pkcs8_ecc_key(asn1_node pkcs8_asn,
gnutls_x509_privkey_t pkey);
static
int pkcs8_key_info(const gnutls_datum_t * raw_key,
_encode_privkey(gnutls_x509_privkey_t pkey, gnutls_datum_t * raw)
{
int ret;
- ASN1_TYPE spk = ASN1_TYPE_EMPTY;
+ asn1_node spk = NULL;
switch (pkey->params.algo) {
case GNUTLS_PK_EDDSA_ED25519:
/*
* Encodes a PKCS #1 private key to a PKCS #8 private key
* info. The output will be allocated and stored into der. Also
- * the ASN1_TYPE of private key info will be returned.
+ * the asn1_node of private key info will be returned.
*/
static int
encode_to_private_key_info(gnutls_x509_privkey_t pkey,
- gnutls_datum_t * der, ASN1_TYPE * pkey_info)
+ gnutls_datum_t * der, asn1_node * pkey_info)
{
int result, len;
uint8_t null = 0;
*/
static int
encode_to_pkcs8_key(schema_id schema, const gnutls_datum_t * der_key,
- const char *password, ASN1_TYPE * out)
+ const char *password, asn1_node * out)
{
int result;
gnutls_datum_t key = { NULL, 0 };
gnutls_datum_t tmp = { NULL, 0 };
- ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
+ asn1_node pkcs8_asn = NULL;
struct pbkdf2_params kdf_params;
struct pbe_enc_params enc_params;
const struct pkcs_cipher_schema_st *s;
void *output_data,
size_t * output_data_size)
{
- ASN1_TYPE pkcs8_asn = NULL, pkey_info;
+ asn1_node pkcs8_asn = NULL, pkey_info;
int ret;
gnutls_datum_t tmp = {NULL, 0};
schema_id schema;
const char *password,
unsigned int flags, gnutls_datum_t * out)
{
- ASN1_TYPE pkcs8_asn = NULL, pkey_info;
+ asn1_node pkcs8_asn = NULL, pkey_info;
int ret;
gnutls_datum_t tmp = {NULL, 0};
schema_id schema;
}
static int pkcs8_key_decrypt(const gnutls_datum_t * raw_key,
- ASN1_TYPE pkcs8_asn, const char *password,
+ asn1_node pkcs8_asn, const char *password,
gnutls_x509_privkey_t pkey)
{
int result, len;
static int check_for_decrypted(const gnutls_datum_t *der)
{
int result;
- ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
+ asn1_node pkcs8_asn = NULL;
if ((result =
asn1_create_element(_gnutls_get_pkix(),
int params_start, params_end, params_len;
struct pbe_enc_params enc_params;
schema_id schema;
- ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
+ asn1_node pkcs8_asn = NULL;
memset(&enc_params, 0, sizeof(enc_params));
unsigned int decrypt)
{
int result;
- ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
+ asn1_node pkcs8_asn = NULL;
if ((result =
asn1_create_element(_gnutls_get_pkix(),
/* Decodes an RSA privateKey from a PKCS8 structure.
*/
static int
-_decode_pkcs8_rsa_key(ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey)
+_decode_pkcs8_rsa_key(asn1_node pkcs8_asn, gnutls_x509_privkey_t pkey)
{
int ret;
gnutls_datum_t tmp = {NULL, 0};
/* Decodes an RSA-PSS privateKey from a PKCS8 structure.
*/
static int
-_decode_pkcs8_rsa_pss_key(ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey)
+_decode_pkcs8_rsa_pss_key(asn1_node pkcs8_asn, gnutls_x509_privkey_t pkey)
{
int ret;
gnutls_datum_t tmp = {NULL, 0};
/* Decodes an ECC privateKey from a PKCS8 structure.
*/
static int
-_decode_pkcs8_ecc_key(ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey)
+_decode_pkcs8_ecc_key(asn1_node pkcs8_asn, gnutls_x509_privkey_t pkey)
{
int ret;
gnutls_datum_t tmp = {NULL, 0};
}
static int
-_decode_pkcs8_eddsa_key(ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey, const char *oid)
+_decode_pkcs8_eddsa_key(asn1_node pkcs8_asn, gnutls_x509_privkey_t pkey, const char *oid)
{
int ret;
gnutls_datum_t tmp;
goto error;
}
} else if (raw_key->data[0] == ASN1_TAG_INTEGER) {
- ASN1_TYPE pkey_asn;
+ asn1_node pkey_asn;
/* Very old format: INTEGER packed in OCTET STRING */
if ((ret = asn1_create_element(_gnutls_get_gnutls_asn(),
}
asn1_delete_structure2(&pkey_asn, ASN1_DELETE_FLAG_ZEROIZE);
} else if (raw_key->data[0] == ASN1_TAG_OCTET_STRING) {
- ASN1_TYPE pkey_asn;
+ asn1_node pkey_asn;
/* format: OCTET STRING packed in OCTET STRING */
if ((ret = asn1_create_element(_gnutls_get_gnutls_asn(),
/* Decodes a GOST privateKey from a PKCS8 structure.
*/
static int
-_decode_pkcs8_gost_key(ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey,
+_decode_pkcs8_gost_key(asn1_node pkcs8_asn, gnutls_x509_privkey_t pkey,
gnutls_pk_algorithm_t algo)
{
int ret;
/* Decodes an DSA privateKey and params from a PKCS8 structure.
*/
static int
-_decode_pkcs8_dsa_key(ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey)
+_decode_pkcs8_dsa_key(asn1_node pkcs8_asn, gnutls_x509_privkey_t pkey)
{
int ret;
gnutls_datum_t tmp = {NULL, 0};
{
int result, len;
char oid[MAX_OID_SIZE];
- ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
+ asn1_node pkcs8_asn = NULL;
gnutls_datum_t sder;
int ret;
struct pbkdf2_params *kdf_params,
struct pbe_enc_params *enc_params)
{
- ASN1_TYPE pasn = ASN1_TYPE_EMPTY;
+ asn1_node pasn = NULL;
int len;
int ret, result;
int _x509_encode_provable_seed(gnutls_x509_privkey_t pkey, gnutls_datum_t *der)
{
- ASN1_TYPE c2;
+ asn1_node c2;
int ret, result;
const char *oid;
int _x509_decode_provable_seed(gnutls_x509_privkey_t pkey, const gnutls_datum_t *der)
{
- ASN1_TYPE c2;
+ asn1_node c2;
int ret, result;
char oid[MAX_OID_SIZE];
int oid_size;
#include <pk.h>
/* This is the same as the _gnutls_x509_sign, but this one will decode
- * the ASN1_TYPE given, and sign the DER data. Actually used to get the DER
+ * the asn1_node given, and sign the DER data. Actually used to get the DER
* of the TBS and sign it on the fly.
*/
int
-_gnutls_x509_get_tbs(ASN1_TYPE cert, const char *tbs_name,
+_gnutls_x509_get_tbs(asn1_node cert, const char *tbs_name,
gnutls_datum_t * tbs)
{
return _gnutls_x509_der_encode(cert, tbs_name, tbs, 0);
/*-
* _gnutls_x509_pkix_sign - This function will sign a CRL or a certificate with a key
- * @src: should contain an ASN1_TYPE
+ * @src: should contain an asn1_node
* @issuer: is the certificate of the certificate issuer
* @issuer_key: holds the issuer's private key
*
* negative error value.
-*/
int
-_gnutls_x509_pkix_sign(ASN1_TYPE src, const char *src_name,
+_gnutls_x509_pkix_sign(asn1_node src, const char *src_name,
gnutls_digest_algorithm_t dig,
unsigned int flags,
gnutls_x509_crt_t issuer,
}
-/* Extracts the time in time_t from the ASN1_TYPE given. When should
+/* Extracts the time in time_t from the asn1_node given. When should
* be something like "tbsCertList.thisUpdate".
*/
#define MAX_TIME 64
-time_t _gnutls_x509_get_time(ASN1_TYPE c2, const char *where, int force_general)
+time_t _gnutls_x509_get_time(asn1_node c2, const char *where, int force_general)
{
char ttime[MAX_TIME];
char name[128];
return c_time;
}
-/* Sets the time in time_t in the ASN1_TYPE given. Where should
+/* Sets the time in time_t in the asn1_node given. Where should
* be something like "tbsCertList.thisUpdate".
*/
int
-_gnutls_x509_set_time(ASN1_TYPE c2, const char *where, time_t tim,
+_gnutls_x509_set_time(asn1_node c2, const char *where, time_t tim,
int force_general)
{
char str_time[MAX_TIME];
* which are of the ANY.
*/
int
-_gnutls_x509_set_raw_time(ASN1_TYPE c2, const char *where, time_t tim)
+_gnutls_x509_set_raw_time(asn1_node c2, const char *where, time_t tim)
{
char str_time[MAX_TIME];
uint8_t buf[128];
static int
_gnutls_x509_validate_sign_params(gnutls_pk_algorithm_t pk_algorithm,
- ASN1_TYPE cert,
+ asn1_node cert,
const char *name,
gnutls_x509_spki_st *sig_params)
{
*
*/
int
-_gnutls_parse_general_name2(ASN1_TYPE src, const char *src_name,
+_gnutls_parse_general_name2(asn1_node src, const char *src_name,
int seq, gnutls_datum_t *dname,
unsigned int *ret_type, int othername_oid)
{
* Type is also returned as a parameter in case of an error.
*/
int
-_gnutls_parse_general_name(ASN1_TYPE src, const char *src_name,
+_gnutls_parse_general_name(asn1_node src, const char *src_name,
int seq, void *name, size_t * name_size,
unsigned int *ret_type, int othername_oid)
{
}
static int
-legacy_parse_aia(ASN1_TYPE src,
+legacy_parse_aia(asn1_node src,
unsigned int seq, int what, gnutls_datum_t * data)
{
int len;
{
int ret;
gnutls_datum_t aia;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
if (crt == NULL) {
gnutls_assert();
gnutls_x509_dn_get_rdn_ava(gnutls_x509_dn_t dn,
int irdn, int iava, gnutls_x509_ava_st * ava)
{
- ASN1_TYPE rdn, elem;
- ASN1_DATA_NODE vnode;
+ asn1_node rdn, elem;
+ asn1_data_node_st vnode;
long len;
int lenlen, remlen, ret;
char rbuf[MAX_NAME_SIZE];
gnutls_subject_alt_names_t sans,
unsigned int flags)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result, ret;
unsigned int i;
gnutls_datum_t san, othername_oid;
int gnutls_x509_ext_export_subject_alt_names(gnutls_subject_alt_names_t sans,
gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result, ret;
unsigned i;
unsigned int flags)
{
int result, ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
gnutls_x509_name_constraints_t nc2 = NULL;
result = asn1_create_element
{
int ret, result;
uint8_t null = 0;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
struct name_constraints_node_st *tmp;
if (nc->permitted == NULL && nc->excluded == NULL)
gnutls_datum_t * id)
{
int result, ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
if (ext->size == 0 || ext->data == NULL) {
gnutls_assert();
int gnutls_x509_ext_export_subject_key_id(const gnutls_datum_t * id,
gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int ret, result;
result =
{
int ret;
unsigned i;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
gnutls_datum_t san, othername_oid;
unsigned type;
int gnutls_x509_ext_export_authority_key_id(gnutls_x509_aki_t aki,
gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
unsigned i;
int result, ret;
int gnutls_x509_ext_import_key_usage(const gnutls_datum_t * ext,
unsigned int *key_usage)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int len, result;
uint8_t str[2];
**/
int gnutls_x509_ext_export_key_usage(unsigned int usage, gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result;
uint8_t str[2];
**/
int gnutls_x509_ext_export_inhibit_anypolicy(unsigned int skipcerts, gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result, ret;
result = asn1_create_element(_gnutls_get_gnutls_asn(), "GNUTLS.DSAPublicKey", &c2);
time_t * expiration)
{
int result, ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
result = asn1_create_element
(_gnutls_get_pkix(), "PKIX1.PrivateKeyUsagePeriod", &c2);
gnutls_datum_t * ext)
{
int result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
result =
asn1_create_element(_gnutls_get_pkix(),
int gnutls_x509_ext_import_basic_constraints(const gnutls_datum_t * ext,
unsigned int *ca, int *pathlen)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
char str[128]="";
int len, result;
int gnutls_x509_ext_export_basic_constraints(unsigned int ca, int pathlen,
gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
const char *str;
int result;
char **policyLanguage, char **policy,
size_t *sizeof_policy)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result;
gnutls_datum_t value1 = { NULL, 0 };
gnutls_datum_t value2 = { NULL, 0 };
const char *policy, size_t sizeof_policy,
gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result;
result = asn1_create_element(_gnutls_get_pkix(),
static int decode_user_notice(const void *data, size_t size,
gnutls_datum_t * txt)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int ret, len;
char choice_type[64];
char name[128];
gnutls_x509_policies_t policies,
unsigned int flags)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
char tmpstr[128];
char tmpoid[MAX_OID_SIZE];
gnutls_datum_t tmpd = { NULL, 0 };
gnutls_datum_t * der_data)
{
int result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
if ((result =
asn1_create_element(_gnutls_get_pkix(),
int result;
unsigned i, j;
gnutls_datum_t der_data = {NULL, 0}, tmpd;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
const char *oid;
result =
unsigned int flags)
{
int result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
char name[MAX_NAME_SIZE];
int len, ret;
uint8_t reasons[2];
int gnutls_x509_ext_export_crl_dist_points(gnutls_x509_crl_dist_points_t cdp,
gnutls_datum_t * ext)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int result;
uint8_t reasons[2];
unsigned i;
}
-static int parse_aia(ASN1_TYPE c2, gnutls_x509_aia_t aia)
+static int parse_aia(asn1_node c2, gnutls_x509_aia_t aia)
{
int len;
char nptr[MAX_NAME_SIZE];
unsigned int flags)
{
int ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
if (ext->size == 0 || ext->data == NULL) {
gnutls_assert();
gnutls_datum_t * ext)
{
int ret, result;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
unsigned int i;
ret = asn1_create_element(_gnutls_get_pkix(),
{
char tmpstr[MAX_NAME_SIZE];
int result, ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
gnutls_datum_t oid = {NULL, 0};
unsigned i;
gnutls_datum_t * ext)
{
int result, ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
unsigned i;
result = asn1_create_element
int _gnutls_x509_decode_ext(const gnutls_datum_t *der, gnutls_x509_ext_st *out)
{
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
char str_critical[10];
char oid[MAX_OID_SIZE];
int result, len, ret;
/* flags can be zero or GNUTLS_EXT_FLAG_APPEND
*/
-static int parse_tlsfeatures(ASN1_TYPE c2, gnutls_x509_tlsfeatures_t f, unsigned flags)
+static int parse_tlsfeatures(asn1_node c2, gnutls_x509_tlsfeatures_t f, unsigned flags)
{
char nptr[MAX_NAME_SIZE];
int result;
unsigned int flags)
{
int ret;
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
if (ext->size == 0 || ext->data == NULL) {
gnutls_assert();
return GNUTLS_E_INVALID_REQUEST;
}
- ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
+ asn1_node c2 = NULL;
int ret;
unsigned i;
struct gnutls_x509_crl_iter {
/* This is used to optimize reads by gnutls_x509_crl_iter_crt_serial() */
- ASN1_TYPE rcache;
+ asn1_node rcache;
unsigned rcache_idx;
};
typedef struct gnutls_x509_crl_int {
- ASN1_TYPE crl;
+ asn1_node crl;
unsigned expanded;
/* This is used to optimize reads by gnutls_x509_crl_get_crt_serial2() */
- ASN1_TYPE rcache;
+ asn1_node rcache;
unsigned rcache_idx;
int use_extensions;
} gnutls_x509_crl_int;
typedef struct gnutls_x509_dn_st {
- ASN1_TYPE asn;
+ asn1_node asn;
} gnutls_x509_dn_st;
typedef struct gnutls_x509_crt_int {
- ASN1_TYPE cert;
+ asn1_node cert;
int use_extensions;
unsigned expanded; /* a certificate has been expanded */
unsigned modified; /* the cached values below may no longer be valid */
#define MODIFIED(crt) crt->modified=1
typedef struct gnutls_x509_crq_int {
- ASN1_TYPE crq;
+ asn1_node crq;
} gnutls_x509_crq_int;
typedef struct gnutls_pkcs7_attrs_st {
} gnutls_pkcs7_attrs_st;
typedef struct gnutls_pkcs7_int {
- ASN1_TYPE pkcs7;
+ asn1_node pkcs7;
char encap_data_oid[MAX_OID_SIZE];
gnutls_datum_t der_signed_data;
- ASN1_TYPE signed_data;
+ asn1_node signed_data;
unsigned expanded;
} gnutls_pkcs7_int;
unsigned expanded;
unsigned flags;
- ASN1_TYPE key;
+ asn1_node key;
struct pin_info_st pin;
} gnutls_x509_privkey_int;
gnutls_datum_t * dn);
/* sign.c */
-int _gnutls_x509_get_tbs(ASN1_TYPE cert, const char *tbs_name,
+int _gnutls_x509_get_tbs(asn1_node cert, const char *tbs_name,
gnutls_datum_t * tbs);
-int _gnutls_x509_pkix_sign(ASN1_TYPE src, const char *src_name,
+int _gnutls_x509_pkix_sign(asn1_node src, const char *src_name,
gnutls_digest_algorithm_t,
unsigned int flags,
gnutls_x509_crt_t issuer,
#define OID_LDAP_UID "0.9.2342.19200300.100.1.1"
#define OID_PKCS9_EMAIL "1.2.840.113549.1.9.1"
-int _gnutls_x509_parse_dn(ASN1_TYPE asn1_struct,
+int _gnutls_x509_parse_dn(asn1_node asn1_struct,
const char *asn1_rdn_name, char *buf,
size_t * sizeof_buf,
unsigned flags);
int
-_gnutls_x509_get_dn(ASN1_TYPE asn1_struct,
+_gnutls_x509_get_dn(asn1_node asn1_struct,
const char *asn1_rdn_name, gnutls_datum_t * dn,
unsigned flags);
int
-_gnutls_x509_parse_dn_oid(ASN1_TYPE asn1_struct,
+_gnutls_x509_parse_dn_oid(asn1_node asn1_struct,
const char *asn1_rdn_name,
const char *given_oid, int indx,
unsigned int raw_flag, gnutls_datum_t * out);
-int _gnutls_x509_set_dn_oid(ASN1_TYPE asn1_struct,
+int _gnutls_x509_set_dn_oid(asn1_node asn1_struct,
const char *asn1_rdn_name, const char *oid,
int raw_flag, const char *name,
int sizeof_name);
-int _gnutls_x509_get_dn_oid(ASN1_TYPE asn1_struct,
+int _gnutls_x509_get_dn_oid(asn1_node asn1_struct,
const char *asn1_rdn_name,
int indx, void *_oid, size_t * sizeof_oid);
int _gnutls_encode_othername_data(unsigned flags, const void *data, unsigned data_size, gnutls_datum_t *output);
-int _gnutls_parse_general_name(ASN1_TYPE src, const char *src_name,
+int _gnutls_parse_general_name(asn1_node src, const char *src_name,
int seq, void *name, size_t * name_size,
unsigned int *ret_type, int othername_oid);
int
-_gnutls_parse_general_name2(ASN1_TYPE src, const char *src_name,
+_gnutls_parse_general_name2(asn1_node src, const char *src_name,
int seq, gnutls_datum_t *dname,
unsigned int *ret_type, int othername_oid);
int
-_gnutls_write_new_general_name(ASN1_TYPE ext, const char *ext_name,
+_gnutls_write_new_general_name(asn1_node ext, const char *ext_name,
gnutls_x509_subject_alt_name_t type,
const void *data, unsigned int data_size);
int
-_gnutls_write_new_othername(ASN1_TYPE ext, const char *ext_name,
+_gnutls_write_new_othername(asn1_node ext, const char *ext_name,
const char *oid,
const void *data, unsigned int data_size);
/* privkey.h */
void _gnutls_x509_privkey_reinit(gnutls_x509_privkey_t key);
-ASN1_TYPE _gnutls_privkey_decode_pkcs1_rsa_key(const gnutls_datum_t *
+asn1_node _gnutls_privkey_decode_pkcs1_rsa_key(const gnutls_datum_t *
raw_key,
gnutls_x509_privkey_t pkey);
-int _gnutls_privkey_decode_ecc_key(ASN1_TYPE* pkey_asn, const gnutls_datum_t *
+int _gnutls_privkey_decode_ecc_key(asn1_node* pkey_asn, const gnutls_datum_t *
raw_key,
gnutls_x509_privkey_t pkey,
gnutls_ecc_curve_t curve);
-int _gnutls_privkey_decode_eddsa_key(ASN1_TYPE* pkey_asn,
+int _gnutls_privkey_decode_eddsa_key(asn1_node* pkey_asn,
const gnutls_datum_t *raw_key,
gnutls_x509_privkey_t pkey,
gnutls_ecc_curve_t curve);
gnutls_pk_params_st * params,
gnutls_pk_algorithm_t algo);
-int _gnutls_asn1_encode_privkey(ASN1_TYPE * c2,
+int _gnutls_asn1_encode_privkey(asn1_node * c2,
gnutls_pk_params_st * params);
void _gnutls_x509_privkey_get_spki_params(gnutls_x509_privkey_t key,
int
-_gnutls_write_general_name(ASN1_TYPE ext, const char *ext_name,
+_gnutls_write_general_name(asn1_node ext, const char *ext_name,
gnutls_x509_subject_alt_name_t type,
const void *data, unsigned int data_size);
int _gnutls_x509_write_pubkey(const gnutls_pk_params_st * params,
gnutls_datum_t * der);
-int _gnutls_x509_read_uint(ASN1_TYPE node, const char *value,
+int _gnutls_x509_read_uint(asn1_node node, const char *value,
unsigned int *ret);
int _gnutls_x509_read_der_int(uint8_t * der, int dersize, bigint_t * out);
int _gnutls_x509_read_der_uint(uint8_t * der, int dersize, unsigned int *out);
-int _gnutls_x509_read_int(ASN1_TYPE node, const char *value,
+int _gnutls_x509_read_int(asn1_node node, const char *value,
bigint_t * ret_mpi);
-int _gnutls_x509_write_int(ASN1_TYPE node, const char *value, bigint_t mpi,
+int _gnutls_x509_write_int(asn1_node node, const char *value, bigint_t mpi,
int lz);
-int _gnutls_x509_write_uint32(ASN1_TYPE node, const char *value,
+int _gnutls_x509_write_uint32(asn1_node node, const char *value,
uint32_t num);
-int _gnutls_x509_read_key_int(ASN1_TYPE node, const char *value,
+int _gnutls_x509_read_key_int(asn1_node node, const char *value,
bigint_t * ret_mpi);
-int _gnutls_x509_write_key_int(ASN1_TYPE node, const char *value, bigint_t mpi,
+int _gnutls_x509_write_key_int(asn1_node node, const char *value, bigint_t mpi,
int lz);
-int _gnutls_x509_read_key_int_le(ASN1_TYPE node, const char *value,
+int _gnutls_x509_read_key_int_le(asn1_node node, const char *value,
bigint_t * ret_mpi);
-int _gnutls_x509_write_key_int_le(ASN1_TYPE node, const char *value,
+int _gnutls_x509_write_key_int_le(asn1_node node, const char *value,
bigint_t mpi);
-int _gnutls_x509_read_pkalgo_params(ASN1_TYPE src, const char *src_name,
+int _gnutls_x509_read_pkalgo_params(asn1_node src, const char *src_name,
gnutls_x509_spki_st *params, unsigned is_sig);
-int _gnutls_x509_write_sign_params(ASN1_TYPE dst, const char *dst_name,
+int _gnutls_x509_write_sign_params(asn1_node dst, const char *dst_name,
const gnutls_sign_entry_st *se, gnutls_x509_spki_st *params);
#define _gnutls_x509_read_sign_params(src,name,params) _gnutls_x509_read_pkalgo_params(src,name,params,1)
#define _gnutls_x509_read_spki_params(src,name,params) _gnutls_x509_read_pkalgo_params(src,name,params,0)
-int _gnutls_x509_write_spki_params(ASN1_TYPE dst, const char *dst_name,
+int _gnutls_x509_write_spki_params(asn1_node dst, const char *dst_name,
gnutls_x509_spki_st *params);
inline static int
#include <gnutls/pkcs12.h>
typedef struct gnutls_pkcs12_int {
- ASN1_TYPE pkcs12;
+ asn1_node pkcs12;
unsigned expanded;
} gnutls_pkcs12_int;
gnutls_pkcs12_bag_t bag);
int
-_pkcs12_encode_safe_contents(gnutls_pkcs12_bag_t bag, ASN1_TYPE * content,
+_pkcs12_encode_safe_contents(gnutls_pkcs12_bag_t bag, asn1_node * content,
int *enc);
int _pkcs12_decode_crt_bag(gnutls_pkcs12_bag_type_t type,
struct name_constraints_node_st *next;
} name_constraints_node_st;
-int _gnutls_extract_name_constraints(ASN1_TYPE c2, const char *vstr,
+int _gnutls_extract_name_constraints(asn1_node c2, const char *vstr,
name_constraints_node_st ** _nc);
void _gnutls_name_constraints_node_free (name_constraints_node_st *node);
int _gnutls_x509_name_constraints_merge(gnutls_x509_name_constraints_t nc,
projects / thirdparty / gnutls.git / commitdiff
