crypto/asn1/a_object.c

/* crypto/asn1/a_object.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdio.h>
#include <limits.h>
#include "cryptlib.h"
#include <openssl/buffer.h>
#include <openssl/asn1.h>
#include <openssl/objects.h>
#include <openssl/bn.h>

int i2d_ASN1_OBJECT(ASN1_OBJECT *a, unsigned char **pp)
{
    unsigned char *p;
    int objsize;

    if ((a == NULL) || (a->data == NULL))
        return (0);

    objsize = ASN1_object_size(0, a->length, V_ASN1_OBJECT);
    if (pp == NULL || objsize == -1)
        return objsize;

    p = *pp;
    ASN1_put_object(&p, 0, a->length, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
    memcpy(p, a->data, a->length);
    p += a->length;

    *pp = p;
    return (objsize);
}

int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
{
    int i, first, len = 0, c, use_bn;
    char ftmp[24], *tmp = ftmp;
    int tmpsize = sizeof ftmp;
    const char *p;
    unsigned long l;
    BIGNUM *bl = NULL;

    if (num == 0)
        return (0);
    else if (num == -1)
        num = strlen(buf);

    p = buf;
    c = *(p++);
    num--;
    if ((c >= '0') && (c <= '2')) {
        first = c - '0';
    } else {
        ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_FIRST_NUM_TOO_LARGE);
        goto err;
    }

    if (num <= 0) {
        ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_MISSING_SECOND_NUMBER);
        goto err;
    }
    c = *(p++);
    num--;
    for (;;) {
        if (num <= 0)
            break;
        if ((c != '.') && (c != ' ')) {
            ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_INVALID_SEPARATOR);
            goto err;
        }
        l = 0;
        use_bn = 0;
        for (;;) {
            if (num <= 0)
                break;
            num--;
            c = *(p++);
            if ((c == ' ') || (c == '.'))
                break;
            if ((c < '0') || (c > '9')) {
                ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_INVALID_DIGIT);
                goto err;
            }
            if (!use_bn && l >= ((ULONG_MAX - 80) / 10L)) {
                use_bn = 1;
                if (!bl)
                    bl = BN_new();
                if (!bl || !BN_set_word(bl, l))
                    goto err;
            }
            if (use_bn) {
                if (!BN_mul_word(bl, 10L)
                    || !BN_add_word(bl, c - '0'))
                    goto err;
            } else
                l = l * 10L + (long)(c - '0');
        }
        if (len == 0) {
            if ((first < 2) && (l >= 40)) {
                ASN1err(ASN1_F_A2D_ASN1_OBJECT,
                        ASN1_R_SECOND_NUMBER_TOO_LARGE);
                goto err;
            }
            if (use_bn) {
                if (!BN_add_word(bl, first * 40))
                    goto err;
            } else
                l += (long)first *40;
        }
        i = 0;
        if (use_bn) {
            int blsize;
            blsize = BN_num_bits(bl);
            blsize = (blsize + 6) / 7;
            if (blsize > tmpsize) {
                if (tmp != ftmp)
                    OPENSSL_free(tmp);
                tmpsize = blsize + 32;
                tmp = OPENSSL_malloc(tmpsize);
                if (!tmp)
                    goto err;
            }
            while (blsize--) {
                BN_ULONG t = BN_div_word(bl, 0x80L);
                if (t == (BN_ULONG)-1)
                    goto err;
                tmp[i++] = (unsigned char)t;
            }
        } else {

            for (;;) {
                tmp[i++] = (unsigned char)l & 0x7f;
                l >>= 7L;
                if (l == 0L)
                    break;
            }

        }
        if (out != NULL) {
            if (len + i > olen) {
                ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_BUFFER_TOO_SMALL);
                goto err;
            }
            while (--i > 0)
                out[len++] = tmp[i] | 0x80;
            out[len++] = tmp[0];
        } else
            len += i;
    }
    if (tmp != ftmp)
        OPENSSL_free(tmp);
    if (bl)
        BN_free(bl);
    return (len);
 err:
    if (tmp != ftmp)
        OPENSSL_free(tmp);
    if (bl)
        BN_free(bl);
    return (0);
}

int i2t_ASN1_OBJECT(char *buf, int buf_len, ASN1_OBJECT *a)
{
    return OBJ_obj2txt(buf, buf_len, a, 0);
}

int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
{
    char buf[80], *p = buf;
    int i;

    if ((a == NULL) || (a->data == NULL))
        return (BIO_write(bp, "NULL", 4));
    i = i2t_ASN1_OBJECT(buf, sizeof buf, a);
    if (i > (int)(sizeof(buf) - 1)) {
        p = OPENSSL_malloc(i + 1);
        if (!p)
            return -1;
        i2t_ASN1_OBJECT(p, i + 1, a);
    }
    if (i <= 0)
        return BIO_write(bp, "<INVALID>", 9);
    BIO_write(bp, p, i);
    if (p != buf)
        OPENSSL_free(p);
    return (i);
}

ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
                             long length)
{
    const unsigned char *p;
    long len;
    int tag, xclass;
    int inf, i;
    ASN1_OBJECT *ret = NULL;
    p = *pp;
    inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
    if (inf & 0x80) {
        i = ASN1_R_BAD_OBJECT_HEADER;
        goto err;
    }

    if (tag != V_ASN1_OBJECT) {
        i = ASN1_R_EXPECTING_AN_OBJECT;
        goto err;
    }
    ret = c2i_ASN1_OBJECT(a, &p, len);
    if (ret)
        *pp = p;
    return ret;
 err:
    ASN1err(ASN1_F_D2I_ASN1_OBJECT, i);
    return (NULL);
}

ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
                             long len)
{
    ASN1_OBJECT *ret = NULL;
    const unsigned char *p;
    unsigned char *data;
    int i, length;

    /*
     * Sanity check OID encoding. Need at least one content octet. MSB must
     * be clear in the last octet. can't have leading 0x80 in subidentifiers,
     * see: X.690 8.19.2
     */
    if (len <= 0 || len > INT_MAX || pp == NULL || (p = *pp) == NULL ||
        p[len - 1] & 0x80) {
        ASN1err(ASN1_F_C2I_ASN1_OBJECT, ASN1_R_INVALID_OBJECT_ENCODING);
        return NULL;
    }
    /* Now 0 < len <= INT_MAX, so the cast is safe. */
    length = (int)len;
    for (i = 0; i < length; i++, p++) {
        if (*p == 0x80 && (!i || !(p[-1] & 0x80))) {
            ASN1err(ASN1_F_C2I_ASN1_OBJECT, ASN1_R_INVALID_OBJECT_ENCODING);
            return NULL;
        }
    }

    /*
     * only the ASN1_OBJECTs from the 'table' will have values for ->sn or
     * ->ln
     */
    if ((a == NULL) || ((*a) == NULL) ||
        !((*a)->flags & ASN1_OBJECT_FLAG_DYNAMIC)) {
        if ((ret = ASN1_OBJECT_new()) == NULL)
            return (NULL);
    } else
        ret = (*a);

    p = *pp;
    /* detach data from object */
    data = (unsigned char *)ret->data;
    ret->data = NULL;
    /* once detached we can change it */
    if ((data == NULL) || (ret->length < length)) {
        ret->length = 0;
        if (data != NULL)
            OPENSSL_free(data);
        data = (unsigned char *)OPENSSL_malloc(length);
        if (data == NULL) {
            i = ERR_R_MALLOC_FAILURE;
            goto err;
        }
        ret->flags |= ASN1_OBJECT_FLAG_DYNAMIC_DATA;
    }
    memcpy(data, p, length);
    /* reattach data to object, after which it remains const */
    ret->data = data;
    ret->length = length;
    ret->sn = NULL;
    ret->ln = NULL;
    /* ret->flags=ASN1_OBJECT_FLAG_DYNAMIC; we know it is dynamic */
    p += length;

    if (a != NULL)
        (*a) = ret;
    *pp = p;
    return (ret);
 err:
    ASN1err(ASN1_F_C2I_ASN1_OBJECT, i);
    if ((ret != NULL) && ((a == NULL) || (*a != ret)))
        ASN1_OBJECT_free(ret);
    return (NULL);
}

ASN1_OBJECT *ASN1_OBJECT_new(void)
{
    ASN1_OBJECT *ret;

    ret = (ASN1_OBJECT *)OPENSSL_malloc(sizeof(ASN1_OBJECT));
    if (ret == NULL) {
        ASN1err(ASN1_F_ASN1_OBJECT_NEW, ERR_R_MALLOC_FAILURE);
        return (NULL);
    }
    ret->length = 0;
    ret->data = NULL;
    ret->nid = 0;
    ret->sn = NULL;
    ret->ln = NULL;
    ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
    return (ret);
}

void ASN1_OBJECT_free(ASN1_OBJECT *a)
{
    if (a == NULL)
        return;
    if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS) {
#ifndef CONST_STRICT            /* disable purely for compile-time strict
                                 * const checking. Doing this on a "real"
                                 * compile will cause memory leaks */
        if (a->sn != NULL)
            OPENSSL_free((void *)a->sn);
        if (a->ln != NULL)
            OPENSSL_free((void *)a->ln);
#endif
        a->sn = a->ln = NULL;
    }
    if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA) {
        if (a->data != NULL)
            OPENSSL_free((void *)a->data);
        a->data = NULL;
        a->length = 0;
    }
    if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
        OPENSSL_free(a);
}

ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
                                const char *sn, const char *ln)
{
    ASN1_OBJECT o;

    o.sn = sn;
    o.ln = ln;
    o.data = data;
    o.nid = nid;
    o.length = len;
    o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
        ASN1_OBJECT_FLAG_DYNAMIC_DATA;
    return (OBJ_dup(&o));
}

IMPLEMENT_STACK_OF(ASN1_OBJECT)

IMPLEMENT_ASN1_SET_OF(ASN1_OBJECT)
Revision:	11605
Committed:	Sun Jul 8 16:16:48 2018 UTC (5 years, 9 months ago) by laffer1
Content type:	text/plain
File size:	12350 byte(s)
Log Message:	import openssl 1.0.1u
#	Content
1	/* crypto/asn1/a_object.c */
2	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3	* All rights reserved.
4	*
5	* This package is an SSL implementation written
6	* by Eric Young (eay@cryptsoft.com).
7	* The implementation was written so as to conform with Netscapes SSL.
8	*
9	* This library is free for commercial and non-commercial use as long as
10	* the following conditions are aheared to. The following conditions
11	* apply to all code found in this distribution, be it the RC4, RSA,
12	* lhash, DES, etc., code; not just the SSL code. The SSL documentation
13	* included with this distribution is covered by the same copyright terms
14	* except that the holder is Tim Hudson (tjh@cryptsoft.com).
15	*
16	* Copyright remains Eric Young's, and as such any Copyright notices in
17	* the code are not to be removed.
18	* If this package is used in a product, Eric Young should be given attribution
19	* as the author of the parts of the library used.
20	* This can be in the form of a textual message at program startup or
21	* in documentation (online or textual) provided with the package.
22	*
23	* Redistribution and use in source and binary forms, with or without
24	* modification, are permitted provided that the following conditions
25	* are met:
26	* 1. Redistributions of source code must retain the copyright
27	* notice, this list of conditions and the following disclaimer.
28	* 2. Redistributions in binary form must reproduce the above copyright
29	* notice, this list of conditions and the following disclaimer in the
30	* documentation and/or other materials provided with the distribution.
31	* 3. All advertising materials mentioning features or use of this software
32	* must display the following acknowledgement:
33	* "This product includes cryptographic software written by
34	* Eric Young (eay@cryptsoft.com)"
35	* The word 'cryptographic' can be left out if the rouines from the library
36	* being used are not cryptographic related :-).
37	* 4. If you include any Windows specific code (or a derivative thereof) from
38	* the apps directory (application code) you must include an acknowledgement:
39	* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40	*
41	* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51	* SUCH DAMAGE.
52	*
53	* The licence and distribution terms for any publically available version or
54	* derivative of this code cannot be changed. i.e. this code cannot simply be
55	* copied and put under another distribution licence
56	* [including the GNU Public Licence.]
57	*/
58
59	#include <stdio.h>
60	#include <limits.h>
61	#include "cryptlib.h"
62	#include <openssl/buffer.h>
63	#include <openssl/asn1.h>
64	#include <openssl/objects.h>
65	#include <openssl/bn.h>
66
67	int i2d_ASN1_OBJECT(ASN1_OBJECT a, unsigned char *pp)
68	{
69	unsigned char *p;
70	int objsize;
71
72	if ((a == NULL) \|\| (a->data == NULL))
73	return (0);
74
75	objsize = ASN1_object_size(0, a->length, V_ASN1_OBJECT);
76	if (pp == NULL \|\| objsize == -1)
77	return objsize;
78
79	p = *pp;
80	ASN1_put_object(&p, 0, a->length, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
81	memcpy(p, a->data, a->length);
82	p += a->length;
83
84	*pp = p;
85	return (objsize);
86	}
87
88	int a2d_ASN1_OBJECT(unsigned char out, int olen, const char buf, int num)
89	{
90	int i, first, len = 0, c, use_bn;
91	char ftmp[24], *tmp = ftmp;
92	int tmpsize = sizeof ftmp;
93	const char *p;
94	unsigned long l;
95	BIGNUM *bl = NULL;
96
97	if (num == 0)
98	return (0);
99	else if (num == -1)
100	num = strlen(buf);
101
102	p = buf;
103	c = *(p++);
104	num--;
105	if ((c >= '0') && (c <= '2')) {
106	first = c - '0';
107	} else {
108	ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_FIRST_NUM_TOO_LARGE);
109	goto err;
110	}
111
112	if (num <= 0) {
113	ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_MISSING_SECOND_NUMBER);
114	goto err;
115	}
116	c = *(p++);
117	num--;
118	for (;;) {
119	if (num <= 0)
120	break;
121	if ((c != '.') && (c != ' ')) {
122	ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_INVALID_SEPARATOR);
123	goto err;
124	}
125	l = 0;
126	use_bn = 0;
127	for (;;) {
128	if (num <= 0)
129	break;
130	num--;
131	c = *(p++);
132	if ((c == ' ') \|\| (c == '.'))
133	break;
134	if ((c < '0') \|\| (c > '9')) {
135	ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_INVALID_DIGIT);
136	goto err;
137	}
138	if (!use_bn && l >= ((ULONG_MAX - 80) / 10L)) {
139	use_bn = 1;
140	if (!bl)
141	bl = BN_new();
142	if (!bl \|\| !BN_set_word(bl, l))
143	goto err;
144	}
145	if (use_bn) {
146	if (!BN_mul_word(bl, 10L)
147	\|\| !BN_add_word(bl, c - '0'))
148	goto err;
149	} else
150	l = l * 10L + (long)(c - '0');
151	}
152	if (len == 0) {
153	if ((first < 2) && (l >= 40)) {
154	ASN1err(ASN1_F_A2D_ASN1_OBJECT,
155	ASN1_R_SECOND_NUMBER_TOO_LARGE);
156	goto err;
157	}
158	if (use_bn) {
159	if (!BN_add_word(bl, first * 40))
160	goto err;
161	} else
162	l += (long)first *40;
163	}
164	i = 0;
165	if (use_bn) {
166	int blsize;
167	blsize = BN_num_bits(bl);
168	blsize = (blsize + 6) / 7;
169	if (blsize > tmpsize) {
170	if (tmp != ftmp)
171	OPENSSL_free(tmp);
172	tmpsize = blsize + 32;
173	tmp = OPENSSL_malloc(tmpsize);
174	if (!tmp)
175	goto err;
176	}
177	while (blsize--) {
178	BN_ULONG t = BN_div_word(bl, 0x80L);
179	if (t == (BN_ULONG)-1)
180	goto err;
181	tmp[i++] = (unsigned char)t;
182	}
183	} else {
184
185	for (;;) {
186	tmp[i++] = (unsigned char)l & 0x7f;
187	l >>= 7L;
188	if (l == 0L)
189	break;
190	}
191
192	}
193	if (out != NULL) {
194	if (len + i > olen) {
195	ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_BUFFER_TOO_SMALL);
196	goto err;
197	}
198	while (--i > 0)
199	out[len++] = tmp[i] \| 0x80;
200	out[len++] = tmp[0];
201	} else
202	len += i;
203	}
204	if (tmp != ftmp)
205	OPENSSL_free(tmp);
206	if (bl)
207	BN_free(bl);
208	return (len);
209	err:
210	if (tmp != ftmp)
211	OPENSSL_free(tmp);
212	if (bl)
213	BN_free(bl);
214	return (0);
215	}
216
217	int i2t_ASN1_OBJECT(char buf, int buf_len, ASN1_OBJECT a)
218	{
219	return OBJ_obj2txt(buf, buf_len, a, 0);
220	}
221
222	int i2a_ASN1_OBJECT(BIO bp, ASN1_OBJECT a)
223	{
224	char buf[80], *p = buf;
225	int i;
226
227	if ((a == NULL) \|\| (a->data == NULL))
228	return (BIO_write(bp, "NULL", 4));
229	i = i2t_ASN1_OBJECT(buf, sizeof buf, a);
230	if (i > (int)(sizeof(buf) - 1)) {
231	p = OPENSSL_malloc(i + 1);
232	if (!p)
233	return -1;
234	i2t_ASN1_OBJECT(p, i + 1, a);
235	}
236	if (i <= 0)
237	return BIO_write(bp, "<INVALID>", 9);
238	BIO_write(bp, p, i);
239	if (p != buf)
240	OPENSSL_free(p);
241	return (i);
242	}
243
244	ASN1_OBJECT d2i_ASN1_OBJECT(ASN1_OBJECT a, const unsigned char *pp,
245	long length)
246	{
247	const unsigned char *p;
248	long len;
249	int tag, xclass;
250	int inf, i;
251	ASN1_OBJECT *ret = NULL;
252	p = *pp;
253	inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
254	if (inf & 0x80) {
255	i = ASN1_R_BAD_OBJECT_HEADER;
256	goto err;
257	}
258
259	if (tag != V_ASN1_OBJECT) {
260	i = ASN1_R_EXPECTING_AN_OBJECT;
261	goto err;
262	}
263	ret = c2i_ASN1_OBJECT(a, &p, len);
264	if (ret)
265	*pp = p;
266	return ret;
267	err:
268	ASN1err(ASN1_F_D2I_ASN1_OBJECT, i);
269	return (NULL);
270	}
271
272	ASN1_OBJECT c2i_ASN1_OBJECT(ASN1_OBJECT a, const unsigned char *pp,
273	long len)
274	{
275	ASN1_OBJECT *ret = NULL;
276	const unsigned char *p;
277	unsigned char *data;
278	int i, length;
279
280	/*
281	* Sanity check OID encoding. Need at least one content octet. MSB must
282	* be clear in the last octet. can't have leading 0x80 in subidentifiers,
283	* see: X.690 8.19.2
284	*/
285	if (len <= 0 \|\| len > INT_MAX \|\| pp == NULL \|\| (p = *pp) == NULL \|\|
286	p[len - 1] & 0x80) {
287	ASN1err(ASN1_F_C2I_ASN1_OBJECT, ASN1_R_INVALID_OBJECT_ENCODING);
288	return NULL;
289	}
290	/* Now 0 < len <= INT_MAX, so the cast is safe. */
291	length = (int)len;
292	for (i = 0; i < length; i++, p++) {
293	if (*p == 0x80 && (!i \|\| !(p[-1] & 0x80))) {
294	ASN1err(ASN1_F_C2I_ASN1_OBJECT, ASN1_R_INVALID_OBJECT_ENCODING);
295	return NULL;
296	}
297	}
298
299	/*
300	* only the ASN1_OBJECTs from the 'table' will have values for ->sn or
301	* ->ln
302	*/
303	if ((a == NULL) \|\| ((*a) == NULL) \|\|
304	!((*a)->flags & ASN1_OBJECT_FLAG_DYNAMIC)) {
305	if ((ret = ASN1_OBJECT_new()) == NULL)
306	return (NULL);
307	} else
308	ret = (*a);
309
310	p = *pp;
311	/* detach data from object */
312	data = (unsigned char *)ret->data;
313	ret->data = NULL;
314	/* once detached we can change it */
315	if ((data == NULL) \|\| (ret->length < length)) {
316	ret->length = 0;
317	if (data != NULL)
318	OPENSSL_free(data);
319	data = (unsigned char *)OPENSSL_malloc(length);
320	if (data == NULL) {
321	i = ERR_R_MALLOC_FAILURE;
322	goto err;
323	}
324	ret->flags \|= ASN1_OBJECT_FLAG_DYNAMIC_DATA;
325	}
326	memcpy(data, p, length);
327	/* reattach data to object, after which it remains const */
328	ret->data = data;
329	ret->length = length;
330	ret->sn = NULL;
331	ret->ln = NULL;
332	/* ret->flags=ASN1_OBJECT_FLAG_DYNAMIC; we know it is dynamic */
333	p += length;
334
335	if (a != NULL)
336	(*a) = ret;
337	*pp = p;
338	return (ret);
339	err:
340	ASN1err(ASN1_F_C2I_ASN1_OBJECT, i);
341	if ((ret != NULL) && ((a == NULL) \|\| (*a != ret)))
342	ASN1_OBJECT_free(ret);
343	return (NULL);
344	}
345
346	ASN1_OBJECT *ASN1_OBJECT_new(void)
347	{
348	ASN1_OBJECT *ret;
349
350	ret = (ASN1_OBJECT *)OPENSSL_malloc(sizeof(ASN1_OBJECT));
351	if (ret == NULL) {
352	ASN1err(ASN1_F_ASN1_OBJECT_NEW, ERR_R_MALLOC_FAILURE);
353	return (NULL);
354	}
355	ret->length = 0;
356	ret->data = NULL;
357	ret->nid = 0;
358	ret->sn = NULL;
359	ret->ln = NULL;
360	ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
361	return (ret);
362	}
363
364	void ASN1_OBJECT_free(ASN1_OBJECT *a)
365	{
366	if (a == NULL)
367	return;
368	if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS) {
369	#ifndef CONST_STRICT /* disable purely for compile-time strict
370	* const checking. Doing this on a "real"
371	* compile will cause memory leaks */
372	if (a->sn != NULL)
373	OPENSSL_free((void *)a->sn);
374	if (a->ln != NULL)
375	OPENSSL_free((void *)a->ln);
376	#endif
377	a->sn = a->ln = NULL;
378	}
379	if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA) {
380	if (a->data != NULL)
381	OPENSSL_free((void *)a->data);
382	a->data = NULL;
383	a->length = 0;
384	}
385	if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
386	OPENSSL_free(a);
387	}
388
389	ASN1_OBJECT ASN1_OBJECT_create(int nid, unsigned char data, int len,
390	const char sn, const char ln)
391	{
392	ASN1_OBJECT o;
393
394	o.sn = sn;
395	o.ln = ln;
396	o.data = data;
397	o.nid = nid;
398	o.length = len;
399	o.flags = ASN1_OBJECT_FLAG_DYNAMIC \| ASN1_OBJECT_FLAG_DYNAMIC_STRINGS \|
400	ASN1_OBJECT_FLAG_DYNAMIC_DATA;
401	return (OBJ_dup(&o));
402	}
403
404	IMPLEMENT_STACK_OF(ASN1_OBJECT)
405
406	IMPLEMENT_ASN1_SET_OF(ASN1_OBJECT)