b94b418ee89a8f1ff424134fe022bccaad3867e3
[openssl.git] / crypto / asn1 / a_object.c
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 "cryptlib.h"
61 #include <openssl/buffer.h>
62 #include <openssl/asn1.h>
63 #include <openssl/objects.h>
64
65 int i2d_ASN1_OBJECT(ASN1_OBJECT *a, unsigned char **pp)
66         {
67         unsigned char *p;
68
69         if ((a == NULL) || (a->data == NULL)) return(0);
70
71         if (pp == NULL)
72                 return(ASN1_object_size(0,a->length,V_ASN1_OBJECT));
73
74         p= *pp;
75         ASN1_put_object(&p,0,a->length,V_ASN1_OBJECT,V_ASN1_UNIVERSAL);
76         memcpy(p,a->data,a->length);
77         p+=a->length;
78
79         *pp=p;
80         return(a->length);
81         }
82
83 int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
84         {
85         int i,first,len=0,c;
86         char tmp[24];
87         const char *p;
88         unsigned long l;
89
90         if (num == 0)
91                 return(0);
92         else if (num == -1)
93                 num=strlen(buf);
94
95         p=buf;
96         c= *(p++);
97         num--;
98         if ((c >= '0') && (c <= '2'))
99                 {
100                 first=(c-'0')*40;
101                 }
102         else
103                 {
104                 ASN1err(ASN1_F_A2D_ASN1_OBJECT,ASN1_R_FIRST_NUM_TOO_LARGE);
105                 goto err;
106                 }
107
108         if (num <= 0)
109                 {
110                 ASN1err(ASN1_F_A2D_ASN1_OBJECT,ASN1_R_MISSING_SECOND_NUMBER);
111                 goto err;
112                 }
113         c= *(p++);
114         num--;
115         for (;;)
116                 {
117                 if (num <= 0) break;
118                 if ((c != '.') && (c != ' '))
119                         {
120                         ASN1err(ASN1_F_A2D_ASN1_OBJECT,ASN1_R_INVALID_SEPARATOR);
121                         goto err;
122                         }
123                 l=0;
124                 for (;;)
125                         {
126                         if (num <= 0) break;
127                         num--;
128                         c= *(p++);
129                         if ((c == ' ') || (c == '.'))
130                                 break;
131                         if ((c < '0') || (c > '9'))
132                                 {
133                                 ASN1err(ASN1_F_A2D_ASN1_OBJECT,ASN1_R_INVALID_DIGIT);
134                                 goto err;
135                                 }
136                         l=l*10L+(long)(c-'0');
137                         }
138                 if (len == 0)
139                         {
140                         if ((first < 2) && (l >= 40))
141                                 {
142                                 ASN1err(ASN1_F_A2D_ASN1_OBJECT,ASN1_R_SECOND_NUMBER_TOO_LARGE);
143                                 goto err;
144                                 }
145                         l+=(long)first;
146                         }
147                 i=0;
148                 for (;;)
149                         {
150                         tmp[i++]=(unsigned char)l&0x7f;
151                         l>>=7L;
152                         if (l == 0L) break;
153                         }
154                 if (out != NULL)
155                         {
156                         if (len+i > olen)
157                                 {
158                                 ASN1err(ASN1_F_A2D_ASN1_OBJECT,ASN1_R_BUFFER_TOO_SMALL);
159                                 goto err;
160                                 }
161                         while (--i > 0)
162                                 out[len++]=tmp[i]|0x80;
163                         out[len++]=tmp[0];
164                         }
165                 else
166                         len+=i;
167                 }
168         return(len);
169 err:
170         return(0);
171         }
172
173 int i2t_ASN1_OBJECT(char *buf, int buf_len, ASN1_OBJECT *a)
174 {
175         return OBJ_obj2txt(buf, buf_len, a, 0);
176 }
177
178 int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
179         {
180         char buf[80];
181         int i;
182
183         if ((a == NULL) || (a->data == NULL))
184                 return(BIO_write(bp,"NULL",4));
185         i=i2t_ASN1_OBJECT(buf,80,a);
186         if (i > 80) i=80;
187         BIO_write(bp,buf,i);
188         return(i);
189         }
190
191 ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, unsigned char **pp,
192              long length)
193         {
194         ASN1_OBJECT *ret=NULL;
195         unsigned char *p;
196         long len;
197         int tag,xclass;
198         int inf,i;
199
200         /* only the ASN1_OBJECTs from the 'table' will have values
201          * for ->sn or ->ln */
202         if ((a == NULL) || ((*a) == NULL) ||
203                 !((*a)->flags & ASN1_OBJECT_FLAG_DYNAMIC))
204                 {
205                 if ((ret=ASN1_OBJECT_new()) == NULL) return(NULL);
206                 }
207         else    ret=(*a);
208
209         p= *pp;
210
211         inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
212         if (inf & 0x80)
213                 {
214                 i=ASN1_R_BAD_OBJECT_HEADER;
215                 goto err;
216                 }
217
218         if (tag != V_ASN1_OBJECT)
219                 {
220                 i=ASN1_R_EXPECTING_AN_OBJECT;
221                 goto err;
222                 }
223         if ((ret->data == NULL) || (ret->length < len))
224                 {
225                 if (ret->data != NULL) Free((char *)ret->data);
226                 ret->data=(unsigned char *)Malloc((int)len);
227                 ret->flags|=ASN1_OBJECT_FLAG_DYNAMIC_DATA;
228                 if (ret->data == NULL)
229                         { i=ERR_R_MALLOC_FAILURE; goto err; }
230                 }
231         memcpy(ret->data,p,(int)len);
232         ret->length=(int)len;
233         ret->sn=NULL;
234         ret->ln=NULL;
235         /* ret->flags=ASN1_OBJECT_FLAG_DYNAMIC; we know it is dynamic */
236         p+=len;
237
238         if (a != NULL) (*a)=ret;
239         *pp=p;
240         return(ret);
241 err:
242         ASN1err(ASN1_F_D2I_ASN1_OBJECT,i);
243         if ((ret != NULL) && ((a == NULL) || (*a != ret)))
244                 ASN1_OBJECT_free(ret);
245         return(NULL);
246         }
247
248 ASN1_OBJECT *ASN1_OBJECT_new(void)
249         {
250         ASN1_OBJECT *ret;
251
252         ret=(ASN1_OBJECT *)Malloc(sizeof(ASN1_OBJECT));
253         if (ret == NULL)
254                 {
255                 ASN1err(ASN1_F_ASN1_OBJECT_NEW,ERR_R_MALLOC_FAILURE);
256                 return(NULL);
257                 }
258         ret->length=0;
259         ret->data=NULL;
260         ret->nid=0;
261         ret->sn=NULL;
262         ret->ln=NULL;
263         ret->flags=ASN1_OBJECT_FLAG_DYNAMIC;
264         return(ret);
265         }
266
267 void ASN1_OBJECT_free(ASN1_OBJECT *a)
268         {
269         if (a == NULL) return;
270         if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS)
271                 {
272 #ifndef CONST_STRICT /* disable purely for compile-time strict const checking. Doing this on a "real" compile will cause mempory leaks */
273                 if (a->sn != NULL) Free((void *)a->sn);
274                 if (a->ln != NULL) Free((void *)a->ln);
275 #endif
276                 a->sn=a->ln=NULL;
277                 }
278         if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA)
279                 {
280                 if (a->data != NULL) Free(a->data);
281                 a->data=NULL;
282                 a->length=0;
283                 }
284         if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
285                 Free(a);
286         }
287
288 ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
289              char *sn, char *ln)
290         {
291         ASN1_OBJECT o;
292
293         o.sn=sn;
294         o.ln=ln;
295         o.data=data;
296         o.nid=nid;
297         o.length=len;
298         o.flags=ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
299                 ASN1_OBJECT_FLAG_DYNAMIC_DATA;
300         return(OBJ_dup(&o));
301         }
302
303 IMPLEMENT_STACK_OF(ASN1_OBJECT)
304 IMPLEMENT_ASN1_SET_OF(ASN1_OBJECT)