dso_dl.c revision 296465 
1/* dso_dl.c -*- mode:C; c-file-style: "eay" -*- */
2/*
3 * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
4 * 2000.
5 */
6/* ====================================================================
7 * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 *
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in
18 *    the documentation and/or other materials provided with the
19 *    distribution.
20 *
21 * 3. All advertising materials mentioning features or use of this
22 *    software must display the following acknowledgment:
23 *    "This product includes software developed by the OpenSSL Project
24 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 *
26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 *    endorse or promote products derived from this software without
28 *    prior written permission. For written permission, please contact
29 *    licensing@OpenSSL.org.
30 *
31 * 5. Products derived from this software may not be called "OpenSSL"
32 *    nor may "OpenSSL" appear in their names without prior written
33 *    permission of the OpenSSL Project.
34 *
35 * 6. Redistributions of any form whatsoever must retain the following
36 *    acknowledgment:
37 *    "This product includes software developed by the OpenSSL Project
38 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 * OF THE POSSIBILITY OF SUCH DAMAGE.
52 * ====================================================================
53 *
54 * This product includes cryptographic software written by Eric Young
55 * (eay@cryptsoft.com).  This product includes software written by Tim
56 * Hudson (tjh@cryptsoft.com).
57 *
58 */
59
60#include <stdio.h>
61#include "cryptlib.h"
62#include <openssl/dso.h>
63
64#ifndef DSO_DL
65DSO_METHOD *DSO_METHOD_dl(void)
66{
67    return NULL;
68}
69#else
70
71# include <dl.h>
72
73/* Part of the hack in "dl_load" ... */
74# define DSO_MAX_TRANSLATED_SIZE 256
75
76static int dl_load(DSO *dso);
77static int dl_unload(DSO *dso);
78static void *dl_bind_var(DSO *dso, const char *symname);
79static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname);
80# if 0
81static int dl_unbind_var(DSO *dso, char *symname, void *symptr);
82static int dl_unbind_func(DSO *dso, char *symname, DSO_FUNC_TYPE symptr);
83static int dl_init(DSO *dso);
84static int dl_finish(DSO *dso);
85static int dl_ctrl(DSO *dso, int cmd, long larg, void *parg);
86# endif
87static char *dl_name_converter(DSO *dso, const char *filename);
88static char *dl_merger(DSO *dso, const char *filespec1,
89                       const char *filespec2);
90
91static DSO_METHOD dso_meth_dl = {
92    "OpenSSL 'dl' shared library method",
93    dl_load,
94    dl_unload,
95    dl_bind_var,
96    dl_bind_func,
97/* For now, "unbind" doesn't exist */
98# if 0
99    NULL,                       /* unbind_var */
100    NULL,                       /* unbind_func */
101# endif
102    NULL,                       /* ctrl */
103    dl_name_converter,
104    dl_merger,
105    NULL,                       /* init */
106    NULL                        /* finish */
107};
108
109DSO_METHOD *DSO_METHOD_dl(void)
110{
111    return (&dso_meth_dl);
112}
113
114/*
115 * For this DSO_METHOD, our meth_data STACK will contain; (i) the handle
116 * (shl_t) returned from shl_load(). NB: I checked on HPUX11 and shl_t is
117 * itself a pointer type so the cast is safe.
118 */
119
120static int dl_load(DSO *dso)
121{
122    shl_t ptr = NULL;
123    /*
124     * We don't do any fancy retries or anything, just take the method's (or
125     * DSO's if it has the callback set) best translation of the
126     * platform-independant filename and try once with that.
127     */
128    char *filename = DSO_convert_filename(dso, NULL);
129
130    if (filename == NULL) {
131        DSOerr(DSO_F_DL_LOAD, DSO_R_NO_FILENAME);
132        goto err;
133    }
134    ptr = shl_load(filename, BIND_IMMEDIATE |
135                   (dso->flags & DSO_FLAG_NO_NAME_TRANSLATION ? 0 :
136                    DYNAMIC_PATH), 0L);
137    if (ptr == NULL) {
138        DSOerr(DSO_F_DL_LOAD, DSO_R_LOAD_FAILED);
139        ERR_add_error_data(4, "filename(", filename, "): ", strerror(errno));
140        goto err;
141    }
142    if (!sk_push(dso->meth_data, (char *)ptr)) {
143        DSOerr(DSO_F_DL_LOAD, DSO_R_STACK_ERROR);
144        goto err;
145    }
146    /*
147     * Success, stick the converted filename we've loaded under into the DSO
148     * (it also serves as the indicator that we are currently loaded).
149     */
150    dso->loaded_filename = filename;
151    return (1);
152 err:
153    /* Cleanup! */
154    if (filename != NULL)
155        OPENSSL_free(filename);
156    if (ptr != NULL)
157        shl_unload(ptr);
158    return (0);
159}
160
161static int dl_unload(DSO *dso)
162{
163    shl_t ptr;
164    if (dso == NULL) {
165        DSOerr(DSO_F_DL_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);
166        return (0);
167    }
168    if (sk_num(dso->meth_data) < 1)
169        return (1);
170    /* Is this statement legal? */
171    ptr = (shl_t) sk_pop(dso->meth_data);
172    if (ptr == NULL) {
173        DSOerr(DSO_F_DL_UNLOAD, DSO_R_NULL_HANDLE);
174        /*
175         * Should push the value back onto the stack in case of a retry.
176         */
177        sk_push(dso->meth_data, (char *)ptr);
178        return (0);
179    }
180    shl_unload(ptr);
181    return (1);
182}
183
184static void *dl_bind_var(DSO *dso, const char *symname)
185{
186    shl_t ptr;
187    void *sym;
188
189    if ((dso == NULL) || (symname == NULL)) {
190        DSOerr(DSO_F_DL_BIND_VAR, ERR_R_PASSED_NULL_PARAMETER);
191        return (NULL);
192    }
193    if (sk_num(dso->meth_data) < 1) {
194        DSOerr(DSO_F_DL_BIND_VAR, DSO_R_STACK_ERROR);
195        return (NULL);
196    }
197    ptr = (shl_t) sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
198    if (ptr == NULL) {
199        DSOerr(DSO_F_DL_BIND_VAR, DSO_R_NULL_HANDLE);
200        return (NULL);
201    }
202    if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0) {
203        DSOerr(DSO_F_DL_BIND_VAR, DSO_R_SYM_FAILURE);
204        ERR_add_error_data(4, "symname(", symname, "): ", strerror(errno));
205        return (NULL);
206    }
207    return (sym);
208}
209
210static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname)
211{
212    shl_t ptr;
213    void *sym;
214
215    if ((dso == NULL) || (symname == NULL)) {
216        DSOerr(DSO_F_DL_BIND_FUNC, ERR_R_PASSED_NULL_PARAMETER);
217        return (NULL);
218    }
219    if (sk_num(dso->meth_data) < 1) {
220        DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_STACK_ERROR);
221        return (NULL);
222    }
223    ptr = (shl_t) sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
224    if (ptr == NULL) {
225        DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_NULL_HANDLE);
226        return (NULL);
227    }
228    if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0) {
229        DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_SYM_FAILURE);
230        ERR_add_error_data(4, "symname(", symname, "): ", strerror(errno));
231        return (NULL);
232    }
233    return ((DSO_FUNC_TYPE)sym);
234}
235
236static char *dl_merger(DSO *dso, const char *filespec1, const char *filespec2)
237{
238    char *merged;
239
240    if (!filespec1 && !filespec2) {
241        DSOerr(DSO_F_DL_MERGER, ERR_R_PASSED_NULL_PARAMETER);
242        return (NULL);
243    }
244    /*
245     * If the first file specification is a rooted path, it rules. same goes
246     * if the second file specification is missing.
247     */
248    if (!filespec2 || filespec1[0] == '/') {
249        merged = OPENSSL_malloc(strlen(filespec1) + 1);
250        if (!merged) {
251            DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
252            return (NULL);
253        }
254        strcpy(merged, filespec1);
255    }
256    /*
257     * If the first file specification is missing, the second one rules.
258     */
259    else if (!filespec1) {
260        merged = OPENSSL_malloc(strlen(filespec2) + 1);
261        if (!merged) {
262            DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
263            return (NULL);
264        }
265        strcpy(merged, filespec2);
266    } else
267        /*
268         * This part isn't as trivial as it looks.  It assumes that the
269         * second file specification really is a directory, and makes no
270         * checks whatsoever.  Therefore, the result becomes the
271         * concatenation of filespec2 followed by a slash followed by
272         * filespec1.
273         */
274    {
275        int spec2len, len;
276
277        spec2len = (filespec2 ? strlen(filespec2) : 0);
278        len = spec2len + (filespec1 ? strlen(filespec1) : 0);
279
280        if (filespec2 && filespec2[spec2len - 1] == '/') {
281            spec2len--;
282            len--;
283        }
284        merged = OPENSSL_malloc(len + 2);
285        if (!merged) {
286            DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
287            return (NULL);
288        }
289        strcpy(merged, filespec2);
290        merged[spec2len] = '/';
291        strcpy(&merged[spec2len + 1], filespec1);
292    }
293    return (merged);
294}
295
296/*
297 * This function is identical to the one in dso_dlfcn.c, but as it is highly
298 * unlikely that both the "dl" *and* "dlfcn" variants are being compiled at
299 * the same time, there's no great duplicating the code. Figuring out an
300 * elegant way to share one copy of the code would be more difficult and
301 * would not leave the implementations independant.
302 */
303# if defined(__hpux)
304static const char extension[] = ".sl";
305# else
306static const char extension[] = ".so";
307# endif
308static char *dl_name_converter(DSO *dso, const char *filename)
309{
310    char *translated;
311    int len, rsize, transform;
312
313    len = strlen(filename);
314    rsize = len + 1;
315    transform = (strstr(filename, "/") == NULL);
316    {
317        /* We will convert this to "%s.s?" or "lib%s.s?" */
318        rsize += strlen(extension); /* The length of ".s?" */
319        if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
320            rsize += 3;         /* The length of "lib" */
321    }
322    translated = OPENSSL_malloc(rsize);
323    if (translated == NULL) {
324        DSOerr(DSO_F_DL_NAME_CONVERTER, DSO_R_NAME_TRANSLATION_FAILED);
325        return (NULL);
326    }
327    if (transform) {
328        if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
329            sprintf(translated, "lib%s%s", filename, extension);
330        else
331            sprintf(translated, "%s%s", filename, extension);
332    } else
333        sprintf(translated, "%s", filename);
334    return (translated);
335}
336
337#endif                          /* DSO_DL */
338