Dead code removal: #if 0 conf, dso, pqueue, threads
[openssl.git] / crypto / dso / dso_dl.c
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
65 DSO_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
76 static int dl_load(DSO *dso);
77 static int dl_unload(DSO *dso);
78 static void *dl_bind_var(DSO *dso, const char *symname);
79 static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname);
80 static char *dl_name_converter(DSO *dso, const char *filename);
81 static char *dl_merger(DSO *dso, const char *filespec1,
82                        const char *filespec2);
83 static int dl_pathbyaddr(void *addr, char *path, int sz);
84 static void *dl_globallookup(const char *name);
85
86 static DSO_METHOD dso_meth_dl = {
87     "OpenSSL 'dl' shared library method",
88     dl_load,
89     dl_unload,
90     dl_bind_var,
91     dl_bind_func,
92     NULL,                       /* ctrl */
93     dl_name_converter,
94     dl_merger,
95     NULL,                       /* init */
96     NULL,                       /* finish */
97     dl_pathbyaddr,
98     dl_globallookup
99 };
100
101 DSO_METHOD *DSO_METHOD_dl(void)
102 {
103     return (&dso_meth_dl);
104 }
105
106 /*
107  * For this DSO_METHOD, our meth_data STACK will contain; (i) the handle
108  * (shl_t) returned from shl_load(). NB: I checked on HPUX11 and shl_t is
109  * itself a pointer type so the cast is safe.
110  */
111
112 static int dl_load(DSO *dso)
113 {
114     shl_t ptr = NULL;
115     /*
116      * We don't do any fancy retries or anything, just take the method's (or
117      * DSO's if it has the callback set) best translation of the
118      * platform-independent filename and try once with that.
119      */
120     char *filename = DSO_convert_filename(dso, NULL);
121
122     if (filename == NULL) {
123         DSOerr(DSO_F_DL_LOAD, DSO_R_NO_FILENAME);
124         goto err;
125     }
126     ptr = shl_load(filename, BIND_IMMEDIATE |
127                    (dso->flags & DSO_FLAG_NO_NAME_TRANSLATION ? 0 :
128                     DYNAMIC_PATH), 0L);
129     if (ptr == NULL) {
130         DSOerr(DSO_F_DL_LOAD, DSO_R_LOAD_FAILED);
131         ERR_add_error_data(4, "filename(", filename, "): ", strerror(errno));
132         goto err;
133     }
134     if (!sk_push(dso->meth_data, (char *)ptr)) {
135         DSOerr(DSO_F_DL_LOAD, DSO_R_STACK_ERROR);
136         goto err;
137     }
138     /*
139      * Success, stick the converted filename we've loaded under into the DSO
140      * (it also serves as the indicator that we are currently loaded).
141      */
142     dso->loaded_filename = filename;
143     return (1);
144  err:
145     /* Cleanup! */
146     if (filename != NULL)
147         OPENSSL_free(filename);
148     if (ptr != NULL)
149         shl_unload(ptr);
150     return (0);
151 }
152
153 static int dl_unload(DSO *dso)
154 {
155     shl_t ptr;
156     if (dso == NULL) {
157         DSOerr(DSO_F_DL_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);
158         return (0);
159     }
160     if (sk_num(dso->meth_data) < 1)
161         return (1);
162     /* Is this statement legal? */
163     ptr = (shl_t) sk_pop(dso->meth_data);
164     if (ptr == NULL) {
165         DSOerr(DSO_F_DL_UNLOAD, DSO_R_NULL_HANDLE);
166         /*
167          * Should push the value back onto the stack in case of a retry.
168          */
169         sk_push(dso->meth_data, (char *)ptr);
170         return (0);
171     }
172     shl_unload(ptr);
173     return (1);
174 }
175
176 static void *dl_bind_var(DSO *dso, const char *symname)
177 {
178     shl_t ptr;
179     void *sym;
180
181     if ((dso == NULL) || (symname == NULL)) {
182         DSOerr(DSO_F_DL_BIND_VAR, ERR_R_PASSED_NULL_PARAMETER);
183         return (NULL);
184     }
185     if (sk_num(dso->meth_data) < 1) {
186         DSOerr(DSO_F_DL_BIND_VAR, DSO_R_STACK_ERROR);
187         return (NULL);
188     }
189     ptr = (shl_t) sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
190     if (ptr == NULL) {
191         DSOerr(DSO_F_DL_BIND_VAR, DSO_R_NULL_HANDLE);
192         return (NULL);
193     }
194     if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0) {
195         DSOerr(DSO_F_DL_BIND_VAR, DSO_R_SYM_FAILURE);
196         ERR_add_error_data(4, "symname(", symname, "): ", strerror(errno));
197         return (NULL);
198     }
199     return (sym);
200 }
201
202 static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname)
203 {
204     shl_t ptr;
205     void *sym;
206
207     if ((dso == NULL) || (symname == NULL)) {
208         DSOerr(DSO_F_DL_BIND_FUNC, ERR_R_PASSED_NULL_PARAMETER);
209         return (NULL);
210     }
211     if (sk_num(dso->meth_data) < 1) {
212         DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_STACK_ERROR);
213         return (NULL);
214     }
215     ptr = (shl_t) sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
216     if (ptr == NULL) {
217         DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_NULL_HANDLE);
218         return (NULL);
219     }
220     if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0) {
221         DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_SYM_FAILURE);
222         ERR_add_error_data(4, "symname(", symname, "): ", strerror(errno));
223         return (NULL);
224     }
225     return ((DSO_FUNC_TYPE)sym);
226 }
227
228 static char *dl_merger(DSO *dso, const char *filespec1, const char *filespec2)
229 {
230     char *merged;
231
232     if (!filespec1 && !filespec2) {
233         DSOerr(DSO_F_DL_MERGER, ERR_R_PASSED_NULL_PARAMETER);
234         return (NULL);
235     }
236     /*
237      * If the first file specification is a rooted path, it rules. same goes
238      * if the second file specification is missing.
239      */
240     if (!filespec2 || filespec1[0] == '/') {
241         merged = OPENSSL_malloc(strlen(filespec1) + 1);
242         if (!merged) {
243             DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
244             return (NULL);
245         }
246         strcpy(merged, filespec1);
247     }
248     /*
249      * If the first file specification is missing, the second one rules.
250      */
251     else if (!filespec1) {
252         merged = OPENSSL_malloc(strlen(filespec2) + 1);
253         if (!merged) {
254             DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
255             return (NULL);
256         }
257         strcpy(merged, filespec2);
258     } else
259         /*
260          * This part isn't as trivial as it looks.  It assumes that the
261          * second file specification really is a directory, and makes no
262          * checks whatsoever.  Therefore, the result becomes the
263          * concatenation of filespec2 followed by a slash followed by
264          * filespec1.
265          */
266     {
267         int spec2len, len;
268
269         spec2len = (filespec2 ? strlen(filespec2) : 0);
270         len = spec2len + (filespec1 ? strlen(filespec1) : 0);
271
272         if (filespec2 && filespec2[spec2len - 1] == '/') {
273             spec2len--;
274             len--;
275         }
276         merged = OPENSSL_malloc(len + 2);
277         if (!merged) {
278             DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
279             return (NULL);
280         }
281         strcpy(merged, filespec2);
282         merged[spec2len] = '/';
283         strcpy(&merged[spec2len + 1], filespec1);
284     }
285     return (merged);
286 }
287
288 /*
289  * This function is identical to the one in dso_dlfcn.c, but as it is highly
290  * unlikely that both the "dl" *and* "dlfcn" variants are being compiled at
291  * the same time, there's no great duplicating the code. Figuring out an
292  * elegant way to share one copy of the code would be more difficult and
293  * would not leave the implementations independent.
294  */
295 # if defined(__hpux)
296 static const char extension[] = ".sl";
297 # else
298 static const char extension[] = ".so";
299 # endif
300 static char *dl_name_converter(DSO *dso, const char *filename)
301 {
302     char *translated;
303     int len, rsize, transform;
304
305     len = strlen(filename);
306     rsize = len + 1;
307     transform = (strstr(filename, "/") == NULL);
308     {
309         /* We will convert this to "%s.s?" or "lib%s.s?" */
310         rsize += strlen(extension); /* The length of ".s?" */
311         if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
312             rsize += 3;         /* The length of "lib" */
313     }
314     translated = OPENSSL_malloc(rsize);
315     if (translated == NULL) {
316         DSOerr(DSO_F_DL_NAME_CONVERTER, DSO_R_NAME_TRANSLATION_FAILED);
317         return (NULL);
318     }
319     if (transform) {
320         if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
321             sprintf(translated, "lib%s%s", filename, extension);
322         else
323             sprintf(translated, "%s%s", filename, extension);
324     } else
325         sprintf(translated, "%s", filename);
326     return (translated);
327 }
328
329 static int dl_pathbyaddr(void *addr, char *path, int sz)
330 {
331     struct shl_descriptor inf;
332     int i, len;
333
334     if (addr == NULL) {
335         union {
336             int (*f) (void *, char *, int);
337             void *p;
338         } t = {
339             dl_pathbyaddr
340         };
341         addr = t.p;
342     }
343
344     for (i = -1; shl_get_r(i, &inf) == 0; i++) {
345         if (((size_t)addr >= inf.tstart && (size_t)addr < inf.tend) ||
346             ((size_t)addr >= inf.dstart && (size_t)addr < inf.dend)) {
347             len = (int)strlen(inf.filename);
348             if (sz <= 0)
349                 return len + 1;
350             if (len >= sz)
351                 len = sz - 1;
352             memcpy(path, inf.filename, len);
353             path[len++] = 0;
354             return len;
355         }
356     }
357
358     return -1;
359 }
360
361 static void *dl_globallookup(const char *name)
362 {
363     void *ret;
364     shl_t h = NULL;
365
366     return shl_findsym(&h, name, TYPE_UNDEFINED, &ret) ? NULL : ret;
367 }
368 #endif                          /* DSO_DL */