[efi-boot-shim.git] / Cryptlib / OpenSSL / crypto / x509 / x509_att.c

/*
 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include <openssl/stack.h>
#include "internal/cryptlib.h"
#include <openssl/asn1.h>
#include <openssl/objects.h>
#include <openssl/evp.h>
#include <openssl/x509.h>
#include <openssl/x509v3.h>
#include "x509_lcl.h"

int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
{
    return sk_X509_ATTRIBUTE_num(x);
}

int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
                           int lastpos)
{
    const ASN1_OBJECT *obj = OBJ_nid2obj(nid);

    if (obj == NULL)
        return (-2);
    return (X509at_get_attr_by_OBJ(x, obj, lastpos));
}

int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
                           const ASN1_OBJECT *obj, int lastpos)
{
    int n;
    X509_ATTRIBUTE *ex;

    if (sk == NULL)
        return (-1);
    lastpos++;
    if (lastpos < 0)
        lastpos = 0;
    n = sk_X509_ATTRIBUTE_num(sk);
    for (; lastpos < n; lastpos++) {
        ex = sk_X509_ATTRIBUTE_value(sk, lastpos);
        if (OBJ_cmp(ex->object, obj) == 0)
            return (lastpos);
    }
    return (-1);
}

X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
{
    if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
        return NULL;
    else
        return sk_X509_ATTRIBUTE_value(x, loc);
}

X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
{
    X509_ATTRIBUTE *ret;

    if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
        return (NULL);
    ret = sk_X509_ATTRIBUTE_delete(x, loc);
    return (ret);
}

STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
                                           X509_ATTRIBUTE *attr)
{
    X509_ATTRIBUTE *new_attr = NULL;
    STACK_OF(X509_ATTRIBUTE) *sk = NULL;

    if (x == NULL) {
        X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER);
        goto err2;
    }

    if (*x == NULL) {
        if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
            goto err;
    } else
        sk = *x;

    if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL)
        goto err2;
    if (!sk_X509_ATTRIBUTE_push(sk, new_attr))
        goto err;
    if (*x == NULL)
        *x = sk;
    return (sk);
 err:
    X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_MALLOC_FAILURE);
 err2:
    X509_ATTRIBUTE_free(new_attr);
    sk_X509_ATTRIBUTE_free(sk);
    return (NULL);
}

STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
                                                  **x, const ASN1_OBJECT *obj,
                                                  int type,
                                                  const unsigned char *bytes,
                                                  int len)
{
    X509_ATTRIBUTE *attr;
    STACK_OF(X509_ATTRIBUTE) *ret;
    attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
    if (!attr)
        return 0;
    ret = X509at_add1_attr(x, attr);
    X509_ATTRIBUTE_free(attr);
    return ret;
}

STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
                                                  **x, int nid, int type,
                                                  const unsigned char *bytes,
                                                  int len)
{
    X509_ATTRIBUTE *attr;
    STACK_OF(X509_ATTRIBUTE) *ret;
    attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
    if (!attr)
        return 0;
    ret = X509at_add1_attr(x, attr);
    X509_ATTRIBUTE_free(attr);
    return ret;
}

STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
                                                  **x, const char *attrname,
                                                  int type,
                                                  const unsigned char *bytes,
                                                  int len)
{
    X509_ATTRIBUTE *attr;
    STACK_OF(X509_ATTRIBUTE) *ret;
    attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
    if (!attr)
        return 0;
    ret = X509at_add1_attr(x, attr);
    X509_ATTRIBUTE_free(attr);
    return ret;
}

void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
                              const ASN1_OBJECT *obj, int lastpos, int type)
{
    int i;
    X509_ATTRIBUTE *at;
    i = X509at_get_attr_by_OBJ(x, obj, lastpos);
    if (i == -1)
        return NULL;
    if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1))
        return NULL;
    at = X509at_get_attr(x, i);
    if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1))
        return NULL;
    return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
}

X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
                                             int atrtype, const void *data,
                                             int len)
{
    ASN1_OBJECT *obj;
    X509_ATTRIBUTE *ret;

    obj = OBJ_nid2obj(nid);
    if (obj == NULL) {
        X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID, X509_R_UNKNOWN_NID);
        return (NULL);
    }
    ret = X509_ATTRIBUTE_create_by_OBJ(attr, obj, atrtype, data, len);
    if (ret == NULL)
        ASN1_OBJECT_free(obj);
    return (ret);
}

X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
                                             const ASN1_OBJECT *obj,
                                             int atrtype, const void *data,
                                             int len)
{
    X509_ATTRIBUTE *ret;

    if ((attr == NULL) || (*attr == NULL)) {
        if ((ret = X509_ATTRIBUTE_new()) == NULL) {
            X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,
                    ERR_R_MALLOC_FAILURE);
            return (NULL);
        }
    } else
        ret = *attr;

    if (!X509_ATTRIBUTE_set1_object(ret, obj))
        goto err;
    if (!X509_ATTRIBUTE_set1_data(ret, atrtype, data, len))
        goto err;

    if ((attr != NULL) && (*attr == NULL))
        *attr = ret;
    return (ret);
 err:
    if ((attr == NULL) || (ret != *attr))
        X509_ATTRIBUTE_free(ret);
    return (NULL);
}

X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
                                             const char *atrname, int type,
                                             const unsigned char *bytes,
                                             int len)
{
    ASN1_OBJECT *obj;
    X509_ATTRIBUTE *nattr;

    obj = OBJ_txt2obj(atrname, 0);
    if (obj == NULL) {
        X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT,
                X509_R_INVALID_FIELD_NAME);
        ERR_add_error_data(2, "name=", atrname);
        return (NULL);
    }
    nattr = X509_ATTRIBUTE_create_by_OBJ(attr, obj, type, bytes, len);
    ASN1_OBJECT_free(obj);
    return nattr;
}

int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
{
    if ((attr == NULL) || (obj == NULL))
        return (0);
    ASN1_OBJECT_free(attr->object);
    attr->object = OBJ_dup(obj);
    return attr->object != NULL;
}

int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
                             const void *data, int len)
{
    ASN1_TYPE *ttmp = NULL;
    ASN1_STRING *stmp = NULL;
    int atype = 0;
    if (!attr)
        return 0;
    if (attrtype & MBSTRING_FLAG) {
        stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
                                      OBJ_obj2nid(attr->object));
        if (!stmp) {
            X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_ASN1_LIB);
            return 0;
        }
        atype = stmp->type;
    } else if (len != -1) {
        if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
            goto err;
        if (!ASN1_STRING_set(stmp, data, len))
            goto err;
        atype = attrtype;
    }
    /*
     * This is a bit naughty because the attribute should really have at
     * least one value but some types use and zero length SET and require
     * this.
     */
    if (attrtype == 0) {
        ASN1_STRING_free(stmp);
        return 1;
    }
    if ((ttmp = ASN1_TYPE_new()) == NULL)
        goto err;
    if ((len == -1) && !(attrtype & MBSTRING_FLAG)) {
        if (!ASN1_TYPE_set1(ttmp, attrtype, data))
            goto err;
    } else {
        ASN1_TYPE_set(ttmp, atype, stmp);
        stmp = NULL;
    }
    if (!sk_ASN1_TYPE_push(attr->set, ttmp))
        goto err;
    return 1;
 err:
    X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE);
    ASN1_TYPE_free(ttmp);
    ASN1_STRING_free(stmp);
    return 0;
}

int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
{
    if (attr == NULL)
        return 0;
    return sk_ASN1_TYPE_num(attr->set);
}

ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
{
    if (attr == NULL)
        return (NULL);
    return (attr->object);
}

void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
                               int atrtype, void *data)
{
    ASN1_TYPE *ttmp;
    ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
    if (!ttmp)
        return NULL;
    if (atrtype != ASN1_TYPE_get(ttmp)) {
        X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE);
        return NULL;
    }
    return ttmp->value.ptr;
}

ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
{
    if (attr == NULL)
        return NULL;
    return sk_ASN1_TYPE_value(attr->set, idx);
}
Commit	Line	Data
7bf7a6d0 MTL	1	/*
7bf7a6d0 MTL	2	* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3e575651	3	*
7bf7a6d0 MTL	4	* Licensed under the OpenSSL license (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
3e575651 SL	8	*/
	9
	10	#include <stdio.h>
	11	#include <openssl/stack.h>
7bf7a6d0	12	#include "internal/cryptlib.h"
3e575651 SL	13	#include <openssl/asn1.h>
	14	#include <openssl/objects.h>
	15	#include <openssl/evp.h>
	16	#include <openssl/x509.h>
	17	#include <openssl/x509v3.h>
7bf7a6d0	18	#include "x509_lcl.h"
3e575651 SL	19
	20	int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
	21	{
d3819813	22	return sk_X509_ATTRIBUTE_num(x);
3e575651 SL	23	}
	24
	25	int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
d3819813	26	int lastpos)
3e575651	27	{
7bf7a6d0	28	const ASN1_OBJECT *obj = OBJ_nid2obj(nid);
3e575651	29
d3819813 MTL	30	if (obj == NULL)
	31	return (-2);
	32	return (X509at_get_attr_by_OBJ(x, obj, lastpos));
3e575651 SL	33	}
3e575651 SL	34
d3819813	35	int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
7bf7a6d0	36	const ASN1_OBJECT *obj, int lastpos)
3e575651	37	{
d3819813 MTL	38	int n;
d3819813 MTL	39	X509_ATTRIBUTE *ex;
3e575651	40
d3819813 MTL	41	if (sk == NULL)
	42	return (-1);
	43	lastpos++;
	44	if (lastpos < 0)
	45	lastpos = 0;
	46	n = sk_X509_ATTRIBUTE_num(sk);
	47	for (; lastpos < n; lastpos++) {
	48	ex = sk_X509_ATTRIBUTE_value(sk, lastpos);
	49	if (OBJ_cmp(ex->object, obj) == 0)
	50	return (lastpos);
	51	}
	52	return (-1);
3e575651 SL	53	}
	54
	55	X509_ATTRIBUTE X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) x, int loc)
	56	{
d3819813 MTL	57	if (x == NULL \|\| sk_X509_ATTRIBUTE_num(x) <= loc \|\| loc < 0)
	58	return NULL;
	59	else
	60	return sk_X509_ATTRIBUTE_value(x, loc);
3e575651 SL	61	}
	62
	63	X509_ATTRIBUTE X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) x, int loc)
	64	{
d3819813	65	X509_ATTRIBUTE *ret;
3e575651	66
d3819813 MTL	67	if (x == NULL \|\| sk_X509_ATTRIBUTE_num(x) <= loc \|\| loc < 0)
	68	return (NULL);
	69	ret = sk_X509_ATTRIBUTE_delete(x, loc);
	70	return (ret);
3e575651 SL	71	}
	72
	73	STACK_OF(X509_ATTRIBUTE) X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) *x,
d3819813	74	X509_ATTRIBUTE *attr)
3e575651	75	{
d3819813 MTL	76	X509_ATTRIBUTE *new_attr = NULL;
d3819813 MTL	77	STACK_OF(X509_ATTRIBUTE) *sk = NULL;
3e575651	78
d3819813 MTL	79	if (x == NULL) {
	80	X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER);
	81	goto err2;
	82	}
3e575651	83
d3819813 MTL	84	if (*x == NULL) {
	85	if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
	86	goto err;
	87	} else
	88	sk = *x;
3e575651	89
d3819813 MTL	90	if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL)
	91	goto err2;
	92	if (!sk_X509_ATTRIBUTE_push(sk, new_attr))
	93	goto err;
	94	if (*x == NULL)
	95	*x = sk;
	96	return (sk);
	97	err:
	98	X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_MALLOC_FAILURE);
	99	err2:
7bf7a6d0 MTL	100	X509_ATTRIBUTE_free(new_attr);
7bf7a6d0 MTL	101	sk_X509_ATTRIBUTE_free(sk);
d3819813	102	return (NULL);
3e575651 SL	103	}
3e575651 SL	104
d3819813 MTL	105	STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
	106	*x, const ASN1_OBJECT obj,
	107	int type,
	108	const unsigned char *bytes,
	109	int len)
3e575651	110	{
d3819813 MTL	111	X509_ATTRIBUTE *attr;
	112	STACK_OF(X509_ATTRIBUTE) *ret;
	113	attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
	114	if (!attr)
	115	return 0;
	116	ret = X509at_add1_attr(x, attr);
	117	X509_ATTRIBUTE_free(attr);
	118	return ret;
3e575651 SL	119	}
3e575651 SL	120
d3819813 MTL	121	STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
	122	**x, int nid, int type,
	123	const unsigned char *bytes,
	124	int len)
3e575651	125	{
d3819813 MTL	126	X509_ATTRIBUTE *attr;
	127	STACK_OF(X509_ATTRIBUTE) *ret;
	128	attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
	129	if (!attr)
	130	return 0;
	131	ret = X509at_add1_attr(x, attr);
	132	X509_ATTRIBUTE_free(attr);
	133	return ret;
3e575651 SL	134	}
3e575651 SL	135
d3819813 MTL	136	STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
	137	*x, const char attrname,
	138	int type,
	139	const unsigned char *bytes,
	140	int len)
3e575651	141	{
d3819813 MTL	142	X509_ATTRIBUTE *attr;
	143	STACK_OF(X509_ATTRIBUTE) *ret;
	144	attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
	145	if (!attr)
	146	return 0;
	147	ret = X509at_add1_attr(x, attr);
	148	X509_ATTRIBUTE_free(attr);
	149	return ret;
3e575651 SL	150	}
	151
	152	void X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) x,
7bf7a6d0	153	const ASN1_OBJECT *obj, int lastpos, int type)
3e575651	154	{
d3819813 MTL	155	int i;
	156	X509_ATTRIBUTE *at;
	157	i = X509at_get_attr_by_OBJ(x, obj, lastpos);
	158	if (i == -1)
	159	return NULL;
	160	if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1))
	161	return NULL;
	162	at = X509at_get_attr(x, i);
	163	if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1))
	164	return NULL;
	165	return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
3e575651 SL	166	}
	167
	168	X509_ATTRIBUTE X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE *attr, int nid,
d3819813 MTL	169	int atrtype, const void *data,
d3819813 MTL	170	int len)
3e575651	171	{
d3819813 MTL	172	ASN1_OBJECT *obj;
d3819813 MTL	173	X509_ATTRIBUTE *ret;
3e575651	174
d3819813 MTL	175	obj = OBJ_nid2obj(nid);
	176	if (obj == NULL) {
	177	X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID, X509_R_UNKNOWN_NID);
	178	return (NULL);
	179	}
	180	ret = X509_ATTRIBUTE_create_by_OBJ(attr, obj, atrtype, data, len);
	181	if (ret == NULL)
	182	ASN1_OBJECT_free(obj);
	183	return (ret);
3e575651 SL	184	}
	185
	186	X509_ATTRIBUTE X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE *attr,
d3819813 MTL	187	const ASN1_OBJECT *obj,
	188	int atrtype, const void *data,
	189	int len)
3e575651	190	{
d3819813	191	X509_ATTRIBUTE *ret;
3e575651	192
d3819813 MTL	193	if ((attr == NULL) \|\| (*attr == NULL)) {
	194	if ((ret = X509_ATTRIBUTE_new()) == NULL) {
	195	X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,
	196	ERR_R_MALLOC_FAILURE);
	197	return (NULL);
	198	}
	199	} else
	200	ret = *attr;
3e575651	201
d3819813 MTL	202	if (!X509_ATTRIBUTE_set1_object(ret, obj))
	203	goto err;
	204	if (!X509_ATTRIBUTE_set1_data(ret, atrtype, data, len))
	205	goto err;
3e575651	206
d3819813 MTL	207	if ((attr != NULL) && (*attr == NULL))
	208	*attr = ret;
	209	return (ret);
	210	err:
	211	if ((attr == NULL) \|\| (ret != *attr))
	212	X509_ATTRIBUTE_free(ret);
	213	return (NULL);
3e575651 SL	214	}
	215
	216	X509_ATTRIBUTE X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE *attr,
d3819813 MTL	217	const char *atrname, int type,
	218	const unsigned char *bytes,
	219	int len)
	220	{
	221	ASN1_OBJECT *obj;
	222	X509_ATTRIBUTE *nattr;
3e575651	223
d3819813 MTL	224	obj = OBJ_txt2obj(atrname, 0);
	225	if (obj == NULL) {
	226	X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT,
	227	X509_R_INVALID_FIELD_NAME);
	228	ERR_add_error_data(2, "name=", atrname);
	229	return (NULL);
	230	}
	231	nattr = X509_ATTRIBUTE_create_by_OBJ(attr, obj, type, bytes, len);
	232	ASN1_OBJECT_free(obj);
	233	return nattr;
	234	}
3e575651 SL	235
	236	int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE attr, const ASN1_OBJECT obj)
	237	{
d3819813 MTL	238	if ((attr == NULL) \|\| (obj == NULL))
	239	return (0);
	240	ASN1_OBJECT_free(attr->object);
	241	attr->object = OBJ_dup(obj);
7bf7a6d0	242	return attr->object != NULL;
3e575651 SL	243	}
3e575651 SL	244
d3819813 MTL	245	int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
d3819813 MTL	246	const void *data, int len)
3e575651	247	{
f4173af1	248	ASN1_TYPE *ttmp = NULL;
d3819813 MTL	249	ASN1_STRING *stmp = NULL;
	250	int atype = 0;
	251	if (!attr)
	252	return 0;
	253	if (attrtype & MBSTRING_FLAG) {
	254	stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
	255	OBJ_obj2nid(attr->object));
	256	if (!stmp) {
	257	X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_ASN1_LIB);
	258	return 0;
	259	}
	260	atype = stmp->type;
	261	} else if (len != -1) {
7bf7a6d0	262	if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
d3819813 MTL	263	goto err;
	264	if (!ASN1_STRING_set(stmp, data, len))
	265	goto err;
	266	atype = attrtype;
	267	}
d3819813 MTL	268	/*
	269	* This is a bit naughty because the attribute should really have at
	270	* least one value but some types use and zero length SET and require
	271	* this.
	272	*/
f4173af1 MTL	273	if (attrtype == 0) {
f4173af1 MTL	274	ASN1_STRING_free(stmp);
d3819813	275	return 1;
f4173af1	276	}
7bf7a6d0	277	if ((ttmp = ASN1_TYPE_new()) == NULL)
d3819813 MTL	278	goto err;
	279	if ((len == -1) && !(attrtype & MBSTRING_FLAG)) {
	280	if (!ASN1_TYPE_set1(ttmp, attrtype, data))
	281	goto err;
f4173af1	282	} else {
d3819813	283	ASN1_TYPE_set(ttmp, atype, stmp);
f4173af1 MTL	284	stmp = NULL;
f4173af1 MTL	285	}
7bf7a6d0	286	if (!sk_ASN1_TYPE_push(attr->set, ttmp))
d3819813 MTL	287	goto err;
	288	return 1;
	289	err:
	290	X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE);
f4173af1 MTL	291	ASN1_TYPE_free(ttmp);
f4173af1 MTL	292	ASN1_STRING_free(stmp);
d3819813	293	return 0;
3e575651 SL	294	}
3e575651 SL	295
7bf7a6d0	296	int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
3e575651	297	{
7bf7a6d0 MTL	298	if (attr == NULL)
	299	return 0;
	300	return sk_ASN1_TYPE_num(attr->set);
3e575651 SL	301	}
	302
	303	ASN1_OBJECT X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE attr)
	304	{
d3819813 MTL	305	if (attr == NULL)
	306	return (NULL);
	307	return (attr->object);
3e575651 SL	308	}
	309
	310	void X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE attr, int idx,
d3819813	311	int atrtype, void *data)
3e575651	312	{
d3819813 MTL	313	ASN1_TYPE *ttmp;
	314	ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
	315	if (!ttmp)
	316	return NULL;
	317	if (atrtype != ASN1_TYPE_get(ttmp)) {
	318	X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE);
	319	return NULL;
	320	}
	321	return ttmp->value.ptr;
3e575651 SL	322	}
	323
	324	ASN1_TYPE X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE attr, int idx)
	325	{
d3819813	326	if (attr == NULL)
d3819813	327	return NULL;
7bf7a6d0	328	return sk_ASN1_TYPE_value(attr->set, idx);
3e575651	329	}