CRYPTO_get_ex_new_index would never return an error.
[openssl.git] / crypto / ex_data.c
1 /* crypto/ex_data.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 <stdlib.h>
61 #include <openssl/buffer.h>
62 #include <openssl/bio.h>
63 #include <openssl/lhash.h>
64 #include "cryptlib.h"
65
66 int CRYPTO_get_ex_new_index(int idx, STACK_OF(CRYPTO_EX_DATA_FUNCS) **skp, long argl, void *argp,
67              CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
68         {
69         int ret= -1;
70         CRYPTO_EX_DATA_FUNCS *a;
71
72         MemCheck_off();
73         if (*skp == NULL)
74                 *skp=sk_CRYPTO_EX_DATA_FUNCS_new_null();
75         if (*skp == NULL)
76                 {
77                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
78                 goto err;
79                 }
80         a=(CRYPTO_EX_DATA_FUNCS *)OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
81         if (a == NULL)
82                 {
83                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
84                 goto err;
85                 }
86         a->argl=argl;
87         a->argp=argp;
88         a->new_func=new_func;
89         a->dup_func=dup_func;
90         a->free_func=free_func;
91         while (sk_CRYPTO_EX_DATA_FUNCS_num(*skp) <= idx)
92                 {
93                 if (!sk_CRYPTO_EX_DATA_FUNCS_push(*skp,NULL))
94                         {
95                         CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
96                         OPENSSL_free(a);
97                         goto err;
98                         }
99                 }
100         sk_CRYPTO_EX_DATA_FUNCS_set(*skp,idx, a);
101         ret=idx;
102 err:
103         MemCheck_on();
104         return(ret);
105         }
106
107 int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val)
108         {
109         int i;
110
111         if (ad->sk == NULL)
112                 {
113                 if ((ad->sk=sk_new_null()) == NULL)
114                         {
115                         CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA,ERR_R_MALLOC_FAILURE);
116                         return(0);
117                         }
118                 }
119         i=sk_num(ad->sk);
120
121         while (i <= idx)
122                 {
123                 if (!sk_push(ad->sk,NULL))
124                         {
125                         CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA,ERR_R_MALLOC_FAILURE);
126                         return(0);
127                         }
128                 i++;
129                 }
130         sk_set(ad->sk,idx,val);
131         return(1);
132         }
133
134 void *CRYPTO_get_ex_data(CRYPTO_EX_DATA *ad, int idx)
135         {
136         if (ad->sk == NULL)
137                 return(0);
138         else if (idx >= sk_num(ad->sk))
139                 return(0);
140         else
141                 return(sk_value(ad->sk,idx));
142         }
143
144 /* The callback is called with the 'object', which is the original data object
145  * being duplicated, a pointer to the
146  * 'new' object to be inserted, the index, and the argi/argp
147  */
148 int CRYPTO_dup_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, CRYPTO_EX_DATA *to,
149              CRYPTO_EX_DATA *from)
150         {
151         int i,j,m,r;
152         CRYPTO_EX_DATA_FUNCS *mm;
153         char *from_d;
154
155         if (meth == NULL) return(1);
156         if (from->sk == NULL) return(1);
157         m=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
158         j=sk_num(from->sk);
159         for (i=0; i<j; i++)
160                 {
161                 from_d=CRYPTO_get_ex_data(from,i);
162                 if (i < m)
163                         {
164                         mm=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
165                         if (mm->dup_func != NULL)
166                                 r=mm->dup_func(to,from,(char **)&from_d,i,
167                                         mm->argl,mm->argp);
168                         }
169                 CRYPTO_set_ex_data(to,i,from_d);
170                 }
171         return(1);
172         }
173
174 /* Call each free callback */
175 void CRYPTO_free_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad)
176         {
177         CRYPTO_EX_DATA_FUNCS *m;
178         void *ptr;
179         int i,max;
180
181         if (meth != NULL)
182                 {
183                 max=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
184                 for (i=0; i<max; i++)
185                         {
186                         m=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
187                         if ((m != NULL) && (m->free_func != NULL))
188                                 {
189                                 ptr=CRYPTO_get_ex_data(ad,i);
190                                 m->free_func(obj,ptr,ad,i,m->argl,m->argp);
191                                 }
192                         }
193                 }
194         if (ad->sk != NULL)
195                 {
196                 sk_free(ad->sk);
197                 ad->sk=NULL;
198                 }
199         }
200
201 void CRYPTO_new_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad)
202         {
203         CRYPTO_EX_DATA_FUNCS *m;
204         void *ptr;
205         int i,max;
206
207         ad->sk=NULL;
208         if (meth != NULL)
209                 {
210                 max=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
211                 for (i=0; i<max; i++)
212                         {
213                         m=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
214                         if ((m != NULL) && (m->new_func != NULL))
215                                 {
216                                 ptr=CRYPTO_get_ex_data(ad,i);
217                                 m->new_func(obj,ptr,ad,i,m->argl,m->argp);
218                                 }
219                         }
220                 }
221         }
222
223 IMPLEMENT_STACK_OF(CRYPTO_EX_DATA_FUNCS)