Branch data Line data Source code
1 : : /* dso_lib.c -*- mode:C; c-file-style: "eay" -*- */
2 : : /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
3 : : * project 2000.
4 : : */
5 : : /* ====================================================================
6 : : * Copyright (c) 2000 The OpenSSL Project. All rights reserved.
7 : : *
8 : : * Redistribution and use in source and binary forms, with or without
9 : : * modification, are permitted provided that the following conditions
10 : : * are met:
11 : : *
12 : : * 1. Redistributions of source code must retain the above copyright
13 : : * notice, this list of conditions and the following disclaimer.
14 : : *
15 : : * 2. Redistributions in binary form must reproduce the above copyright
16 : : * notice, this list of conditions and the following disclaimer in
17 : : * the documentation and/or other materials provided with the
18 : : * distribution.
19 : : *
20 : : * 3. All advertising materials mentioning features or use of this
21 : : * software must display the following acknowledgment:
22 : : * "This product includes software developed by the OpenSSL Project
23 : : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 : : *
25 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 : : * endorse or promote products derived from this software without
27 : : * prior written permission. For written permission, please contact
28 : : * licensing@OpenSSL.org.
29 : : *
30 : : * 5. Products derived from this software may not be called "OpenSSL"
31 : : * nor may "OpenSSL" appear in their names without prior written
32 : : * permission of the OpenSSL Project.
33 : : *
34 : : * 6. Redistributions of any form whatsoever must retain the following
35 : : * acknowledgment:
36 : : * "This product includes software developed by the OpenSSL Project
37 : : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 : : *
39 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
51 : : * ====================================================================
52 : : *
53 : : * This product includes cryptographic software written by Eric Young
54 : : * (eay@cryptsoft.com). This product includes software written by Tim
55 : : * Hudson (tjh@cryptsoft.com).
56 : : *
57 : : */
58 : :
59 : : #include <stdio.h>
60 : : #include <openssl/crypto.h>
61 : : #include "cryptlib.h"
62 : : #include <openssl/dso.h>
63 : :
64 : : static DSO_METHOD *default_DSO_meth = NULL;
65 : :
66 : 0 : DSO *DSO_new(void)
67 : : {
68 : 0 : return(DSO_new_method(NULL));
69 : : }
70 : :
71 : 0 : void DSO_set_default_method(DSO_METHOD *meth)
72 : : {
73 : 0 : default_DSO_meth = meth;
74 : 0 : }
75 : :
76 : 0 : DSO_METHOD *DSO_get_default_method(void)
77 : : {
78 : 0 : return(default_DSO_meth);
79 : : }
80 : :
81 : 0 : DSO_METHOD *DSO_get_method(DSO *dso)
82 : : {
83 : 0 : return(dso->meth);
84 : : }
85 : :
86 : 0 : DSO_METHOD *DSO_set_method(DSO *dso, DSO_METHOD *meth)
87 : : {
88 : : DSO_METHOD *mtmp;
89 : 0 : mtmp = dso->meth;
90 : 0 : dso->meth = meth;
91 : 0 : return(mtmp);
92 : : }
93 : :
94 : 3154 : DSO *DSO_new_method(DSO_METHOD *meth)
95 : : {
96 : : DSO *ret;
97 : :
98 [ + + ]: 3154 : if(default_DSO_meth == NULL)
99 : : /* We default to DSO_METH_openssl() which in turn defaults
100 : : * to stealing the "best available" method. Will fallback
101 : : * to DSO_METH_null() in the worst case. */
102 : 398 : default_DSO_meth = DSO_METHOD_openssl();
103 : 3154 : ret = (DSO *)OPENSSL_malloc(sizeof(DSO));
104 [ - + ]: 3154 : if(ret == NULL)
105 : : {
106 : 0 : DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
107 : 0 : return(NULL);
108 : : }
109 : : memset(ret, 0, sizeof(DSO));
110 : 3154 : ret->meth_data = sk_void_new_null();
111 [ - + ]: 3154 : if(ret->meth_data == NULL)
112 : : {
113 : : /* sk_new doesn't generate any errors so we do */
114 : 0 : DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
115 : 0 : OPENSSL_free(ret);
116 : 0 : return(NULL);
117 : : }
118 [ + - ]: 3154 : if(meth == NULL)
119 : 3154 : ret->meth = default_DSO_meth;
120 : : else
121 : 0 : ret->meth = meth;
122 : 3154 : ret->references = 1;
123 [ - + ][ # # ]: 3154 : if((ret->meth->init != NULL) && !ret->meth->init(ret))
124 : : {
125 : 0 : OPENSSL_free(ret);
126 : 0 : ret=NULL;
127 : : }
128 : 3154 : return(ret);
129 : : }
130 : :
131 : 3154 : int DSO_free(DSO *dso)
132 : : {
133 : : int i;
134 : :
135 [ - + ]: 3154 : if(dso == NULL)
136 : : {
137 : 0 : DSOerr(DSO_F_DSO_FREE,ERR_R_PASSED_NULL_PARAMETER);
138 : 0 : return(0);
139 : : }
140 : :
141 : 3154 : i=CRYPTO_add(&dso->references,-1,CRYPTO_LOCK_DSO);
142 : : #ifdef REF_PRINT
143 : : REF_PRINT("DSO",dso);
144 : : #endif
145 [ + - ]: 3154 : if(i > 0) return(1);
146 : : #ifdef REF_CHECK
147 : : if(i < 0)
148 : : {
149 : : fprintf(stderr,"DSO_free, bad reference count\n");
150 : : abort();
151 : : }
152 : : #endif
153 : :
154 [ + - ][ - + ]: 3154 : if((dso->meth->dso_unload != NULL) && !dso->meth->dso_unload(dso))
155 : : {
156 : 0 : DSOerr(DSO_F_DSO_FREE,DSO_R_UNLOAD_FAILED);
157 : 0 : return(0);
158 : : }
159 : :
160 [ - + ][ # # ]: 3154 : if((dso->meth->finish != NULL) && !dso->meth->finish(dso))
161 : : {
162 : 0 : DSOerr(DSO_F_DSO_FREE,DSO_R_FINISH_FAILED);
163 : 0 : return(0);
164 : : }
165 : :
166 : 3154 : sk_void_free(dso->meth_data);
167 [ + - ]: 3154 : if(dso->filename != NULL)
168 : 3154 : OPENSSL_free(dso->filename);
169 [ - + ]: 3154 : if(dso->loaded_filename != NULL)
170 : 0 : OPENSSL_free(dso->loaded_filename);
171 : :
172 : 3154 : OPENSSL_free(dso);
173 : 3154 : return(1);
174 : : }
175 : :
176 : 6308 : int DSO_flags(DSO *dso)
177 : : {
178 [ + - ]: 6308 : return((dso == NULL) ? 0 : dso->flags);
179 : : }
180 : :
181 : :
182 : 0 : int DSO_up_ref(DSO *dso)
183 : : {
184 [ # # ]: 0 : if (dso == NULL)
185 : : {
186 : 0 : DSOerr(DSO_F_DSO_UP_REF,ERR_R_PASSED_NULL_PARAMETER);
187 : 0 : return(0);
188 : : }
189 : :
190 : 0 : CRYPTO_add(&dso->references,1,CRYPTO_LOCK_DSO);
191 : 0 : return(1);
192 : : }
193 : :
194 : 3154 : DSO *DSO_load(DSO *dso, const char *filename, DSO_METHOD *meth, int flags)
195 : : {
196 : : DSO *ret;
197 : 3154 : int allocated = 0;
198 : :
199 [ + - ]: 3154 : if(dso == NULL)
200 : : {
201 : 3154 : ret = DSO_new_method(meth);
202 [ - + ]: 3154 : if(ret == NULL)
203 : : {
204 : 0 : DSOerr(DSO_F_DSO_LOAD,ERR_R_MALLOC_FAILURE);
205 : 0 : goto err;
206 : : }
207 : 3154 : allocated = 1;
208 : : /* Pass the provided flags to the new DSO object */
209 [ - + ]: 3154 : if(DSO_ctrl(ret, DSO_CTRL_SET_FLAGS, flags, NULL) < 0)
210 : : {
211 : 0 : DSOerr(DSO_F_DSO_LOAD,DSO_R_CTRL_FAILED);
212 : 0 : goto err;
213 : : }
214 : : }
215 : : else
216 : : ret = dso;
217 : : /* Don't load if we're currently already loaded */
218 [ - + ]: 3154 : if(ret->filename != NULL)
219 : : {
220 : 0 : DSOerr(DSO_F_DSO_LOAD,DSO_R_DSO_ALREADY_LOADED);
221 : 0 : goto err;
222 : : }
223 : : /* filename can only be NULL if we were passed a dso that already has
224 : : * one set. */
225 [ + - ]: 3154 : if(filename != NULL)
226 [ - + ]: 3154 : if(!DSO_set_filename(ret, filename))
227 : : {
228 : 0 : DSOerr(DSO_F_DSO_LOAD,DSO_R_SET_FILENAME_FAILED);
229 : 0 : goto err;
230 : : }
231 : 3154 : filename = ret->filename;
232 [ - + ]: 3154 : if(filename == NULL)
233 : : {
234 : 0 : DSOerr(DSO_F_DSO_LOAD,DSO_R_NO_FILENAME);
235 : 0 : goto err;
236 : : }
237 [ - + ]: 3154 : if(ret->meth->dso_load == NULL)
238 : : {
239 : 0 : DSOerr(DSO_F_DSO_LOAD,DSO_R_UNSUPPORTED);
240 : 0 : goto err;
241 : : }
242 [ + - ]: 3154 : if(!ret->meth->dso_load(ret))
243 : : {
244 : 3154 : DSOerr(DSO_F_DSO_LOAD,DSO_R_LOAD_FAILED);
245 : 3154 : goto err;
246 : : }
247 : : /* Load succeeded */
248 : : return(ret);
249 : : err:
250 [ + - ]: 3154 : if(allocated)
251 : 3154 : DSO_free(ret);
252 : : return(NULL);
253 : : }
254 : :
255 : 0 : void *DSO_bind_var(DSO *dso, const char *symname)
256 : : {
257 : 0 : void *ret = NULL;
258 : :
259 [ # # ]: 0 : if((dso == NULL) || (symname == NULL))
260 : : {
261 : 0 : DSOerr(DSO_F_DSO_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);
262 : 0 : return(NULL);
263 : : }
264 [ # # ]: 0 : if(dso->meth->dso_bind_var == NULL)
265 : : {
266 : 0 : DSOerr(DSO_F_DSO_BIND_VAR,DSO_R_UNSUPPORTED);
267 : 0 : return(NULL);
268 : : }
269 [ # # ]: 0 : if((ret = dso->meth->dso_bind_var(dso, symname)) == NULL)
270 : : {
271 : 0 : DSOerr(DSO_F_DSO_BIND_VAR,DSO_R_SYM_FAILURE);
272 : 0 : return(NULL);
273 : : }
274 : : /* Success */
275 : : return(ret);
276 : : }
277 : :
278 : 0 : DSO_FUNC_TYPE DSO_bind_func(DSO *dso, const char *symname)
279 : : {
280 : 0 : DSO_FUNC_TYPE ret = NULL;
281 : :
282 [ # # ]: 0 : if((dso == NULL) || (symname == NULL))
283 : : {
284 : 0 : DSOerr(DSO_F_DSO_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
285 : 0 : return(NULL);
286 : : }
287 [ # # ]: 0 : if(dso->meth->dso_bind_func == NULL)
288 : : {
289 : 0 : DSOerr(DSO_F_DSO_BIND_FUNC,DSO_R_UNSUPPORTED);
290 : 0 : return(NULL);
291 : : }
292 [ # # ]: 0 : if((ret = dso->meth->dso_bind_func(dso, symname)) == NULL)
293 : : {
294 : 0 : DSOerr(DSO_F_DSO_BIND_FUNC,DSO_R_SYM_FAILURE);
295 : 0 : return(NULL);
296 : : }
297 : : /* Success */
298 : : return(ret);
299 : : }
300 : :
301 : : /* I don't really like these *_ctrl functions very much to be perfectly
302 : : * honest. For one thing, I think I have to return a negative value for
303 : : * any error because possible DSO_ctrl() commands may return values
304 : : * such as "size"s that can legitimately be zero (making the standard
305 : : * "if(DSO_cmd(...))" form that works almost everywhere else fail at
306 : : * odd times. I'd prefer "output" values to be passed by reference and
307 : : * the return value as success/failure like usual ... but we conform
308 : : * when we must... :-) */
309 : 3154 : long DSO_ctrl(DSO *dso, int cmd, long larg, void *parg)
310 : : {
311 [ - + ]: 3154 : if(dso == NULL)
312 : : {
313 : 0 : DSOerr(DSO_F_DSO_CTRL,ERR_R_PASSED_NULL_PARAMETER);
314 : 0 : return(-1);
315 : : }
316 : : /* We should intercept certain generic commands and only pass control
317 : : * to the method-specific ctrl() function if it's something we don't
318 : : * handle. */
319 [ - + - - ]: 3154 : switch(cmd)
320 : : {
321 : : case DSO_CTRL_GET_FLAGS:
322 : 0 : return dso->flags;
323 : : case DSO_CTRL_SET_FLAGS:
324 : 3154 : dso->flags = (int)larg;
325 : 3154 : return(0);
326 : : case DSO_CTRL_OR_FLAGS:
327 : 0 : dso->flags |= (int)larg;
328 : 0 : return(0);
329 : : default:
330 : : break;
331 : : }
332 [ # # ][ # # ]: 0 : if((dso->meth == NULL) || (dso->meth->dso_ctrl == NULL))
333 : : {
334 : 0 : DSOerr(DSO_F_DSO_CTRL,DSO_R_UNSUPPORTED);
335 : 0 : return(-1);
336 : : }
337 : 0 : return(dso->meth->dso_ctrl(dso,cmd,larg,parg));
338 : : }
339 : :
340 : 0 : int DSO_set_name_converter(DSO *dso, DSO_NAME_CONVERTER_FUNC cb,
341 : : DSO_NAME_CONVERTER_FUNC *oldcb)
342 : : {
343 [ # # ]: 0 : if(dso == NULL)
344 : : {
345 : 0 : DSOerr(DSO_F_DSO_SET_NAME_CONVERTER,
346 : : ERR_R_PASSED_NULL_PARAMETER);
347 : 0 : return(0);
348 : : }
349 [ # # ]: 0 : if(oldcb)
350 : 0 : *oldcb = dso->name_converter;
351 : 0 : dso->name_converter = cb;
352 : 0 : return(1);
353 : : }
354 : :
355 : 0 : const char *DSO_get_filename(DSO *dso)
356 : : {
357 [ # # ]: 0 : if(dso == NULL)
358 : : {
359 : 0 : DSOerr(DSO_F_DSO_GET_FILENAME,ERR_R_PASSED_NULL_PARAMETER);
360 : 0 : return(NULL);
361 : : }
362 : 0 : return(dso->filename);
363 : : }
364 : :
365 : 3154 : int DSO_set_filename(DSO *dso, const char *filename)
366 : : {
367 : : char *copied;
368 : :
369 [ - + ]: 3154 : if((dso == NULL) || (filename == NULL))
370 : : {
371 : 0 : DSOerr(DSO_F_DSO_SET_FILENAME,ERR_R_PASSED_NULL_PARAMETER);
372 : 0 : return(0);
373 : : }
374 [ - + ]: 3154 : if(dso->loaded_filename)
375 : : {
376 : 0 : DSOerr(DSO_F_DSO_SET_FILENAME,DSO_R_DSO_ALREADY_LOADED);
377 : 0 : return(0);
378 : : }
379 : : /* We'll duplicate filename */
380 : 3154 : copied = OPENSSL_malloc(strlen(filename) + 1);
381 [ - + ]: 3154 : if(copied == NULL)
382 : : {
383 : 0 : DSOerr(DSO_F_DSO_SET_FILENAME,ERR_R_MALLOC_FAILURE);
384 : 0 : return(0);
385 : : }
386 : 3154 : BUF_strlcpy(copied, filename, strlen(filename) + 1);
387 [ - + ]: 3154 : if(dso->filename)
388 : 0 : OPENSSL_free(dso->filename);
389 : 3154 : dso->filename = copied;
390 : 3154 : return(1);
391 : : }
392 : :
393 : 0 : char *DSO_merge(DSO *dso, const char *filespec1, const char *filespec2)
394 : : {
395 : 0 : char *result = NULL;
396 : :
397 [ # # ]: 0 : if(dso == NULL || filespec1 == NULL)
398 : : {
399 : 0 : DSOerr(DSO_F_DSO_MERGE,ERR_R_PASSED_NULL_PARAMETER);
400 : 0 : return(NULL);
401 : : }
402 [ # # ]: 0 : if((dso->flags & DSO_FLAG_NO_NAME_TRANSLATION) == 0)
403 : : {
404 [ # # ]: 0 : if(dso->merger != NULL)
405 : 0 : result = dso->merger(dso, filespec1, filespec2);
406 [ # # ]: 0 : else if(dso->meth->dso_merger != NULL)
407 : 0 : result = dso->meth->dso_merger(dso,
408 : : filespec1, filespec2);
409 : : }
410 : 0 : return(result);
411 : : }
412 : :
413 : 3154 : char *DSO_convert_filename(DSO *dso, const char *filename)
414 : : {
415 : 3154 : char *result = NULL;
416 : :
417 [ - + ]: 3154 : if(dso == NULL)
418 : : {
419 : 0 : DSOerr(DSO_F_DSO_CONVERT_FILENAME,ERR_R_PASSED_NULL_PARAMETER);
420 : 0 : return(NULL);
421 : : }
422 [ + - ]: 3154 : if(filename == NULL)
423 : 3154 : filename = dso->filename;
424 [ - + ]: 3154 : if(filename == NULL)
425 : : {
426 : 0 : DSOerr(DSO_F_DSO_CONVERT_FILENAME,DSO_R_NO_FILENAME);
427 : 0 : return(NULL);
428 : : }
429 [ + - ]: 3154 : if((dso->flags & DSO_FLAG_NO_NAME_TRANSLATION) == 0)
430 : : {
431 [ - + ]: 3154 : if(dso->name_converter != NULL)
432 : 0 : result = dso->name_converter(dso, filename);
433 [ + - ]: 3154 : else if(dso->meth->dso_name_converter != NULL)
434 : 3154 : result = dso->meth->dso_name_converter(dso, filename);
435 : : }
436 [ - + ]: 3154 : if(result == NULL)
437 : : {
438 : 0 : result = OPENSSL_malloc(strlen(filename) + 1);
439 [ # # ]: 0 : if(result == NULL)
440 : : {
441 : 0 : DSOerr(DSO_F_DSO_CONVERT_FILENAME,
442 : : ERR_R_MALLOC_FAILURE);
443 : 0 : return(NULL);
444 : : }
445 : 0 : BUF_strlcpy(result, filename, strlen(filename) + 1);
446 : : }
447 : 3154 : return(result);
448 : : }
449 : :
450 : 0 : const char *DSO_get_loaded_filename(DSO *dso)
451 : : {
452 [ # # ]: 0 : if(dso == NULL)
453 : : {
454 : 0 : DSOerr(DSO_F_DSO_GET_LOADED_FILENAME,
455 : : ERR_R_PASSED_NULL_PARAMETER);
456 : 0 : return(NULL);
457 : : }
458 : 0 : return(dso->loaded_filename);
459 : : }
460 : :
461 : 0 : int DSO_pathbyaddr(void *addr,char *path,int sz)
462 : : {
463 : 0 : DSO_METHOD *meth = default_DSO_meth;
464 [ # # ]: 0 : if (meth == NULL) meth = DSO_METHOD_openssl();
465 [ # # ]: 0 : if (meth->pathbyaddr == NULL)
466 : : {
467 : 0 : DSOerr(DSO_F_DSO_PATHBYADDR,DSO_R_UNSUPPORTED);
468 : 0 : return -1;
469 : : }
470 : 0 : return (*meth->pathbyaddr)(addr,path,sz);
471 : : }
472 : :
473 : 0 : void *DSO_global_lookup(const char *name)
474 : : {
475 : 0 : DSO_METHOD *meth = default_DSO_meth;
476 [ # # ]: 0 : if (meth == NULL) meth = DSO_METHOD_openssl();
477 [ # # ]: 0 : if (meth->globallookup == NULL)
478 : : {
479 : 0 : DSOerr(DSO_F_DSO_GLOBAL_LOOKUP,DSO_R_UNSUPPORTED);
480 : 0 : return NULL;
481 : : }
482 : 0 : return (*meth->globallookup)(name);
483 : : }
|
