← Back to branch summary

~ubuntu-branches/ubuntu/precise/openssl098/precise

« back to all changes in this revision

Viewing changes to crypto/dso/dso_lib.c

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2011-03-23 19:50:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110323195031-6h9crj4bymhhr8b8
Tags: upstream-0.9.8o
Import upstream version 0.9.8o

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/dso/dso_lib.c
 
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
DSO *DSO_new(void)
 
67
        {
 
68
        return(DSO_new_method(NULL));
 
69
        }
 
70
 
 
71
void DSO_set_default_method(DSO_METHOD *meth)
 
72
        {
 
73
        default_DSO_meth = meth;
 
74
        }
 
75
 
 
76
DSO_METHOD *DSO_get_default_method(void)
 
77
        {
 
78
        return(default_DSO_meth);
 
79
        }
 
80
 
 
81
DSO_METHOD *DSO_get_method(DSO *dso)
 
82
        {
 
83
        return(dso->meth);
 
84
        }
 
85
 
 
86
DSO_METHOD *DSO_set_method(DSO *dso, DSO_METHOD *meth)
 
87
        {
 
88
        DSO_METHOD *mtmp;
 
89
        mtmp = dso->meth;
 
90
        dso->meth = meth;
 
91
        return(mtmp);
 
92
        }
 
93
 
 
94
DSO *DSO_new_method(DSO_METHOD *meth)
 
95
        {
 
96
        DSO *ret;
 
97
 
 
98
        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
                default_DSO_meth = DSO_METHOD_openssl();
 
103
        ret = (DSO *)OPENSSL_malloc(sizeof(DSO));
 
104
        if(ret == NULL)
 
105
                {
 
106
                DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
 
107
                return(NULL);
 
108
                }
 
109
        memset(ret, 0, sizeof(DSO));
 
110
        ret->meth_data = sk_new_null();
 
111
        if(ret->meth_data == NULL)
 
112
                {
 
113
                /* sk_new doesn't generate any errors so we do */
 
114
                DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
 
115
                OPENSSL_free(ret);
 
116
                return(NULL);
 
117
                }
 
118
        if(meth == NULL)
 
119
                ret->meth = default_DSO_meth;
 
120
        else
 
121
                ret->meth = meth;
 
122
        ret->references = 1;
 
123
        if((ret->meth->init != NULL) && !ret->meth->init(ret))
 
124
                {
 
125
                OPENSSL_free(ret);
 
126
                ret=NULL;
 
127
                }
 
128
        return(ret);
 
129
        }
 
130
 
 
131
int DSO_free(DSO *dso)
 
132
        {
 
133
        int i;
 
134
 
 
135
        if(dso == NULL)
 
136
                {
 
137
                DSOerr(DSO_F_DSO_FREE,ERR_R_PASSED_NULL_PARAMETER);
 
138
                return(0);
 
139
                }
 
140
 
 
141
        i=CRYPTO_add(&dso->references,-1,CRYPTO_LOCK_DSO);
 
142
#ifdef REF_PRINT
 
143
        REF_PRINT("DSO",dso);
 
144
#endif
 
145
        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
        if((dso->meth->dso_unload != NULL) && !dso->meth->dso_unload(dso))
 
155
                {
 
156
                DSOerr(DSO_F_DSO_FREE,DSO_R_UNLOAD_FAILED);
 
157
                return(0);
 
158
                }
 
159
 
 
160
        if((dso->meth->finish != NULL) && !dso->meth->finish(dso))
 
161
                {
 
162
                DSOerr(DSO_F_DSO_FREE,DSO_R_FINISH_FAILED);
 
163
                return(0);
 
164
                }
 
165
        
 
166
        sk_free(dso->meth_data);
 
167
        if(dso->filename != NULL)
 
168
                OPENSSL_free(dso->filename);
 
169
        if(dso->loaded_filename != NULL)
 
170
                OPENSSL_free(dso->loaded_filename);
 
171
 
 
172
        OPENSSL_free(dso);
 
173
        return(1);
 
174
        }
 
175
 
 
176
int DSO_flags(DSO *dso)
 
177
        {
 
178
        return((dso == NULL) ? 0 : dso->flags);
 
179
        }
 
180
 
 
181
 
 
182
int DSO_up_ref(DSO *dso)
 
183
        {
 
184
        if (dso == NULL)
 
185
                {
 
186
                DSOerr(DSO_F_DSO_UP_REF,ERR_R_PASSED_NULL_PARAMETER);
 
187
                return(0);
 
188
                }
 
189
 
 
190
        CRYPTO_add(&dso->references,1,CRYPTO_LOCK_DSO);
 
191
        return(1);
 
192
        }
 
193
 
 
194
DSO *DSO_load(DSO *dso, const char *filename, DSO_METHOD *meth, int flags)
 
195
        {
 
196
        DSO *ret;
 
197
        int allocated = 0;
 
198
 
 
199
        if(dso == NULL)
 
200
                {
 
201
                ret = DSO_new_method(meth);
 
202
                if(ret == NULL)
 
203
                        {
 
204
                        DSOerr(DSO_F_DSO_LOAD,ERR_R_MALLOC_FAILURE);
 
205
                        goto err;
 
206
                        }
 
207
                allocated = 1;
 
208
                /* Pass the provided flags to the new DSO object */
 
209
                if(DSO_ctrl(ret, DSO_CTRL_SET_FLAGS, flags, NULL) < 0)
 
210
                        {
 
211
                        DSOerr(DSO_F_DSO_LOAD,DSO_R_CTRL_FAILED);
 
212
                        goto err;
 
213
                        }
 
214
                }
 
215
        else
 
216
                ret = dso;
 
217
        /* Don't load if we're currently already loaded */
 
218
        if(ret->filename != NULL)
 
219
                {
 
220
                DSOerr(DSO_F_DSO_LOAD,DSO_R_DSO_ALREADY_LOADED);
 
221
                goto err;
 
222
                }
 
223
        /* filename can only be NULL if we were passed a dso that already has
 
224
         * one set. */
 
225
        if(filename != NULL)
 
226
                if(!DSO_set_filename(ret, filename))
 
227
                        {
 
228
                        DSOerr(DSO_F_DSO_LOAD,DSO_R_SET_FILENAME_FAILED);
 
229
                        goto err;
 
230
                        }
 
231
        filename = ret->filename;
 
232
        if(filename == NULL)
 
233
                {
 
234
                DSOerr(DSO_F_DSO_LOAD,DSO_R_NO_FILENAME);
 
235
                goto err;
 
236
                }
 
237
        if(ret->meth->dso_load == NULL)
 
238
                {
 
239
                DSOerr(DSO_F_DSO_LOAD,DSO_R_UNSUPPORTED);
 
240
                goto err;
 
241
                }
 
242
        if(!ret->meth->dso_load(ret))
 
243
                {
 
244
                DSOerr(DSO_F_DSO_LOAD,DSO_R_LOAD_FAILED);
 
245
                goto err;
 
246
                }
 
247
        /* Load succeeded */
 
248
        return(ret);
 
249
err:
 
250
        if(allocated)
 
251
                DSO_free(ret);
 
252
        return(NULL);
 
253
        }
 
254
 
 
255
void *DSO_bind_var(DSO *dso, const char *symname)
 
256
        {
 
257
        void *ret = NULL;
 
258
 
 
259
        if((dso == NULL) || (symname == NULL))
 
260
                {
 
261
                DSOerr(DSO_F_DSO_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);
 
262
                return(NULL);
 
263
                }
 
264
        if(dso->meth->dso_bind_var == NULL)
 
265
                {
 
266
                DSOerr(DSO_F_DSO_BIND_VAR,DSO_R_UNSUPPORTED);
 
267
                return(NULL);
 
268
                }
 
269
        if((ret = dso->meth->dso_bind_var(dso, symname)) == NULL)
 
270
                {
 
271
                DSOerr(DSO_F_DSO_BIND_VAR,DSO_R_SYM_FAILURE);
 
272
                return(NULL);
 
273
                }
 
274
        /* Success */
 
275
        return(ret);
 
276
        }
 
277
 
 
278
DSO_FUNC_TYPE DSO_bind_func(DSO *dso, const char *symname)
 
279
        {
 
280
        DSO_FUNC_TYPE ret = NULL;
 
281
 
 
282
        if((dso == NULL) || (symname == NULL))
 
283
                {
 
284
                DSOerr(DSO_F_DSO_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
 
285
                return(NULL);
 
286
                }
 
287
        if(dso->meth->dso_bind_func == NULL)
 
288
                {
 
289
                DSOerr(DSO_F_DSO_BIND_FUNC,DSO_R_UNSUPPORTED);
 
290
                return(NULL);
 
291
                }
 
292
        if((ret = dso->meth->dso_bind_func(dso, symname)) == NULL)
 
293
                {
 
294
                DSOerr(DSO_F_DSO_BIND_FUNC,DSO_R_SYM_FAILURE);
 
295
                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
long DSO_ctrl(DSO *dso, int cmd, long larg, void *parg)
 
310
        {
 
311
        if(dso == NULL)
 
312
                {
 
313
                DSOerr(DSO_F_DSO_CTRL,ERR_R_PASSED_NULL_PARAMETER);
 
314
                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
        switch(cmd)
 
320
                {
 
321
        case DSO_CTRL_GET_FLAGS:
 
322
                return dso->flags;
 
323
        case DSO_CTRL_SET_FLAGS:
 
324
                dso->flags = (int)larg;
 
325
                return(0);
 
326
        case DSO_CTRL_OR_FLAGS:
 
327
                dso->flags |= (int)larg;
 
328
                return(0);
 
329
        default:
 
330
                break;
 
331
                }
 
332
        if((dso->meth == NULL) || (dso->meth->dso_ctrl == NULL))
 
333
                {
 
334
                DSOerr(DSO_F_DSO_CTRL,DSO_R_UNSUPPORTED);
 
335
                return(-1);
 
336
                }
 
337
        return(dso->meth->dso_ctrl(dso,cmd,larg,parg));
 
338
        }
 
339
 
 
340
int DSO_set_name_converter(DSO *dso, DSO_NAME_CONVERTER_FUNC cb,
 
341
                        DSO_NAME_CONVERTER_FUNC *oldcb)
 
342
        {
 
343
        if(dso == NULL)
 
344
                {
 
345
                DSOerr(DSO_F_DSO_SET_NAME_CONVERTER,
 
346
                                ERR_R_PASSED_NULL_PARAMETER);
 
347
                return(0);
 
348
                }
 
349
        if(oldcb)
 
350
                *oldcb = dso->name_converter;
 
351
        dso->name_converter = cb;
 
352
        return(1);
 
353
        }
 
354
 
 
355
const char *DSO_get_filename(DSO *dso)
 
356
        {
 
357
        if(dso == NULL)
 
358
                {
 
359
                DSOerr(DSO_F_DSO_GET_FILENAME,ERR_R_PASSED_NULL_PARAMETER);
 
360
                return(NULL);
 
361
                }
 
362
        return(dso->filename);
 
363
        }
 
364
 
 
365
int DSO_set_filename(DSO *dso, const char *filename)
 
366
        {
 
367
        char *copied;
 
368
 
 
369
        if((dso == NULL) || (filename == NULL))
 
370
                {
 
371
                DSOerr(DSO_F_DSO_SET_FILENAME,ERR_R_PASSED_NULL_PARAMETER);
 
372
                return(0);
 
373
                }
 
374
        if(dso->loaded_filename)
 
375
                {
 
376
                DSOerr(DSO_F_DSO_SET_FILENAME,DSO_R_DSO_ALREADY_LOADED);
 
377
                return(0);
 
378
                }
 
379
        /* We'll duplicate filename */
 
380
        copied = OPENSSL_malloc(strlen(filename) + 1);
 
381
        if(copied == NULL)
 
382
                {
 
383
                DSOerr(DSO_F_DSO_SET_FILENAME,ERR_R_MALLOC_FAILURE);
 
384
                return(0);
 
385
                }
 
386
        BUF_strlcpy(copied, filename, strlen(filename) + 1);
 
387
        if(dso->filename)
 
388
                OPENSSL_free(dso->filename);
 
389
        dso->filename = copied;
 
390
        return(1);
 
391
        }
 
392
 
 
393
char *DSO_merge(DSO *dso, const char *filespec1, const char *filespec2)
 
394
        {
 
395
        char *result = NULL;
 
396
 
 
397
        if(dso == NULL || filespec1 == NULL)
 
398
                {
 
399
                DSOerr(DSO_F_DSO_MERGE,ERR_R_PASSED_NULL_PARAMETER);
 
400
                return(NULL);
 
401
                }
 
402
        if(filespec1 == NULL)
 
403
                filespec1 = dso->filename;
 
404
        if(filespec1 == NULL)
 
405
                {
 
406
                DSOerr(DSO_F_DSO_MERGE,DSO_R_NO_FILE_SPECIFICATION);
 
407
                return(NULL);
 
408
                }
 
409
        if((dso->flags & DSO_FLAG_NO_NAME_TRANSLATION) == 0)
 
410
                {
 
411
                if(dso->merger != NULL)
 
412
                        result = dso->merger(dso, filespec1, filespec2);
 
413
                else if(dso->meth->dso_merger != NULL)
 
414
                        result = dso->meth->dso_merger(dso,
 
415
                                filespec1, filespec2);
 
416
                }
 
417
        return(result);
 
418
        }
 
419
 
 
420
char *DSO_convert_filename(DSO *dso, const char *filename)
 
421
        {
 
422
        char *result = NULL;
 
423
 
 
424
        if(dso == NULL)
 
425
                {
 
426
                DSOerr(DSO_F_DSO_CONVERT_FILENAME,ERR_R_PASSED_NULL_PARAMETER);
 
427
                return(NULL);
 
428
                }
 
429
        if(filename == NULL)
 
430
                filename = dso->filename;
 
431
        if(filename == NULL)
 
432
                {
 
433
                DSOerr(DSO_F_DSO_CONVERT_FILENAME,DSO_R_NO_FILENAME);
 
434
                return(NULL);
 
435
                }
 
436
        if((dso->flags & DSO_FLAG_NO_NAME_TRANSLATION) == 0)
 
437
                {
 
438
                if(dso->name_converter != NULL)
 
439
                        result = dso->name_converter(dso, filename);
 
440
                else if(dso->meth->dso_name_converter != NULL)
 
441
                        result = dso->meth->dso_name_converter(dso, filename);
 
442
                }
 
443
        if(result == NULL)
 
444
                {
 
445
                result = OPENSSL_malloc(strlen(filename) + 1);
 
446
                if(result == NULL)
 
447
                        {
 
448
                        DSOerr(DSO_F_DSO_CONVERT_FILENAME,
 
449
                                        ERR_R_MALLOC_FAILURE);
 
450
                        return(NULL);
 
451
                        }
 
452
                BUF_strlcpy(result, filename, strlen(filename) + 1);
 
453
                }
 
454
        return(result);
 
455
        }
 
456
 
 
457
const char *DSO_get_loaded_filename(DSO *dso)
 
458
        {
 
459
        if(dso == NULL)
 
460
                {
 
461
                DSOerr(DSO_F_DSO_GET_LOADED_FILENAME,
 
462
                                ERR_R_PASSED_NULL_PARAMETER);
 
463
                return(NULL);
 
464
                }
 
465
        return(dso->loaded_filename);
 
466
        }