b6155b141b527b31a5a418fb5430976b06f5cd3c
[openssl.git] / crypto / dso / dso_dlfcn.c
1 /*
2  * Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project
3  * 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 /*
60  * We need to do this early, because stdio.h includes the header files that
61  * handle _GNU_SOURCE and other similar macros.  Defining it later is simply
62  * too late, because those headers are protected from re- inclusion.
63  */
64 #ifndef _GNU_SOURCE
65 # define _GNU_SOURCE            /* make sure dladdr is declared */
66 #endif
67
68 #include <stdio.h>
69 #include "internal/cryptlib.h"
70 #include <openssl/dso.h>
71
72 #ifndef DSO_DLFCN
73 DSO_METHOD *DSO_METHOD_dlfcn(void)
74 {
75     return NULL;
76 }
77 #else
78
79 # ifdef HAVE_DLFCN_H
80 #  ifdef __osf__
81 #   define __EXTENSIONS__
82 #  endif
83 #  include <dlfcn.h>
84 #  define HAVE_DLINFO 1
85 #  if defined(_AIX) || defined(__CYGWIN__) || \
86      defined(__SCO_VERSION__) || defined(_SCO_ELF) || \
87      (defined(__osf__) && !defined(RTLD_NEXT))     || \
88      (defined(__OpenBSD__) && !defined(RTLD_SELF)) || \
89         defined(__ANDROID__)
90 #   undef HAVE_DLINFO
91 #  endif
92 # endif
93
94 /* Part of the hack in "dlfcn_load" ... */
95 # define DSO_MAX_TRANSLATED_SIZE 256
96
97 static int dlfcn_load(DSO *dso);
98 static int dlfcn_unload(DSO *dso);
99 static void *dlfcn_bind_var(DSO *dso, const char *symname);
100 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname);
101 static char *dlfcn_name_converter(DSO *dso, const char *filename);
102 static char *dlfcn_merger(DSO *dso, const char *filespec1,
103                           const char *filespec2);
104 static int dlfcn_pathbyaddr(void *addr, char *path, int sz);
105 static void *dlfcn_globallookup(const char *name);
106
107 static DSO_METHOD dso_meth_dlfcn = {
108     "OpenSSL 'dlfcn' shared library method",
109     dlfcn_load,
110     dlfcn_unload,
111     dlfcn_bind_var,
112     dlfcn_bind_func,
113     NULL,                       /* ctrl */
114     dlfcn_name_converter,
115     dlfcn_merger,
116     NULL,                       /* init */
117     NULL,                       /* finish */
118     dlfcn_pathbyaddr,
119     dlfcn_globallookup
120 };
121
122 DSO_METHOD *DSO_METHOD_dlfcn(void)
123 {
124     return (&dso_meth_dlfcn);
125 }
126
127 /*
128  * Prior to using the dlopen() function, we should decide on the flag we
129  * send. There's a few different ways of doing this and it's a messy
130  * venn-diagram to match up which platforms support what. So as we don't have
131  * autoconf yet, I'm implementing a hack that could be hacked further
132  * relatively easily to deal with cases as we find them. Initially this is to
133  * cope with OpenBSD.
134  */
135 # if defined(__OpenBSD__) || defined(__NetBSD__)
136 #  ifdef DL_LAZY
137 #   define DLOPEN_FLAG DL_LAZY
138 #  else
139 #   ifdef RTLD_NOW
140 #    define DLOPEN_FLAG RTLD_NOW
141 #   else
142 #    define DLOPEN_FLAG 0
143 #   endif
144 #  endif
145 # else
146 #  define DLOPEN_FLAG RTLD_NOW  /* Hope this works everywhere else */
147 # endif
148
149 /*
150  * For this DSO_METHOD, our meth_data STACK will contain; (i) the handle
151  * (void*) returned from dlopen().
152  */
153
154 static int dlfcn_load(DSO *dso)
155 {
156     void *ptr = NULL;
157     /* See applicable comments in dso_dl.c */
158     char *filename = DSO_convert_filename(dso, NULL);
159     int flags = DLOPEN_FLAG;
160
161     if (filename == NULL) {
162         DSOerr(DSO_F_DLFCN_LOAD, DSO_R_NO_FILENAME);
163         goto err;
164     }
165 # ifdef RTLD_GLOBAL
166     if (dso->flags & DSO_FLAG_GLOBAL_SYMBOLS)
167         flags |= RTLD_GLOBAL;
168 # endif
169     ptr = dlopen(filename, flags);
170     if (ptr == NULL) {
171         DSOerr(DSO_F_DLFCN_LOAD, DSO_R_LOAD_FAILED);
172         ERR_add_error_data(4, "filename(", filename, "): ", dlerror());
173         goto err;
174     }
175     if (!sk_void_push(dso->meth_data, (char *)ptr)) {
176         DSOerr(DSO_F_DLFCN_LOAD, DSO_R_STACK_ERROR);
177         goto err;
178     }
179     /* Success */
180     dso->loaded_filename = filename;
181     return (1);
182  err:
183     /* Cleanup! */
184     OPENSSL_free(filename);
185     if (ptr != NULL)
186         dlclose(ptr);
187     return (0);
188 }
189
190 static int dlfcn_unload(DSO *dso)
191 {
192     void *ptr;
193     if (dso == NULL) {
194         DSOerr(DSO_F_DLFCN_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);
195         return (0);
196     }
197     if (sk_void_num(dso->meth_data) < 1)
198         return (1);
199     ptr = sk_void_pop(dso->meth_data);
200     if (ptr == NULL) {
201         DSOerr(DSO_F_DLFCN_UNLOAD, DSO_R_NULL_HANDLE);
202         /*
203          * Should push the value back onto the stack in case of a retry.
204          */
205         sk_void_push(dso->meth_data, ptr);
206         return (0);
207     }
208     /* For now I'm not aware of any errors associated with dlclose() */
209     dlclose(ptr);
210     return (1);
211 }
212
213 static void *dlfcn_bind_var(DSO *dso, const char *symname)
214 {
215     void *ptr, *sym;
216
217     if ((dso == NULL) || (symname == NULL)) {
218         DSOerr(DSO_F_DLFCN_BIND_VAR, ERR_R_PASSED_NULL_PARAMETER);
219         return (NULL);
220     }
221     if (sk_void_num(dso->meth_data) < 1) {
222         DSOerr(DSO_F_DLFCN_BIND_VAR, DSO_R_STACK_ERROR);
223         return (NULL);
224     }
225     ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
226     if (ptr == NULL) {
227         DSOerr(DSO_F_DLFCN_BIND_VAR, DSO_R_NULL_HANDLE);
228         return (NULL);
229     }
230     sym = dlsym(ptr, symname);
231     if (sym == NULL) {
232         DSOerr(DSO_F_DLFCN_BIND_VAR, DSO_R_SYM_FAILURE);
233         ERR_add_error_data(4, "symname(", symname, "): ", dlerror());
234         return (NULL);
235     }
236     return (sym);
237 }
238
239 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname)
240 {
241     void *ptr;
242     union {
243         DSO_FUNC_TYPE sym;
244         void *dlret;
245     } u;
246
247     if ((dso == NULL) || (symname == NULL)) {
248         DSOerr(DSO_F_DLFCN_BIND_FUNC, ERR_R_PASSED_NULL_PARAMETER);
249         return (NULL);
250     }
251     if (sk_void_num(dso->meth_data) < 1) {
252         DSOerr(DSO_F_DLFCN_BIND_FUNC, DSO_R_STACK_ERROR);
253         return (NULL);
254     }
255     ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
256     if (ptr == NULL) {
257         DSOerr(DSO_F_DLFCN_BIND_FUNC, DSO_R_NULL_HANDLE);
258         return (NULL);
259     }
260     u.dlret = dlsym(ptr, symname);
261     if (u.dlret == NULL) {
262         DSOerr(DSO_F_DLFCN_BIND_FUNC, DSO_R_SYM_FAILURE);
263         ERR_add_error_data(4, "symname(", symname, "): ", dlerror());
264         return (NULL);
265     }
266     return u.sym;
267 }
268
269 static char *dlfcn_merger(DSO *dso, const char *filespec1,
270                           const char *filespec2)
271 {
272     char *merged;
273
274     if (!filespec1 && !filespec2) {
275         DSOerr(DSO_F_DLFCN_MERGER, ERR_R_PASSED_NULL_PARAMETER);
276         return (NULL);
277     }
278     /*
279      * If the first file specification is a rooted path, it rules. same goes
280      * if the second file specification is missing.
281      */
282     if (!filespec2 || (filespec1 != NULL && filespec1[0] == '/')) {
283         merged = OPENSSL_strdup(filespec1);
284         if (merged == NULL) {
285             DSOerr(DSO_F_DLFCN_MERGER, ERR_R_MALLOC_FAILURE);
286             return (NULL);
287         }
288     }
289     /*
290      * If the first file specification is missing, the second one rules.
291      */
292     else if (!filespec1) {
293         merged = OPENSSL_strdup(filespec2);
294         if (merged == NULL) {
295             DSOerr(DSO_F_DLFCN_MERGER, ERR_R_MALLOC_FAILURE);
296             return (NULL);
297         }
298     } else {
299         /*
300          * This part isn't as trivial as it looks.  It assumes that the
301          * second file specification really is a directory, and makes no
302          * checks whatsoever.  Therefore, the result becomes the
303          * concatenation of filespec2 followed by a slash followed by
304          * filespec1.
305          */
306         int spec2len, len;
307
308         spec2len = strlen(filespec2);
309         len = spec2len + strlen(filespec1);
310
311         if (spec2len && filespec2[spec2len - 1] == '/') {
312             spec2len--;
313             len--;
314         }
315         merged = OPENSSL_malloc(len + 2);
316         if (merged == NULL) {
317             DSOerr(DSO_F_DLFCN_MERGER, ERR_R_MALLOC_FAILURE);
318             return (NULL);
319         }
320         strcpy(merged, filespec2);
321         merged[spec2len] = '/';
322         strcpy(&merged[spec2len + 1], filespec1);
323     }
324     return (merged);
325 }
326
327 # ifdef OPENSSL_SYS_MACOSX
328 #  define DSO_ext ".dylib"
329 #  define DSO_extlen 6
330 # else
331 #  define DSO_ext ".so"
332 #  define DSO_extlen 3
333 # endif
334
335 static char *dlfcn_name_converter(DSO *dso, const char *filename)
336 {
337     char *translated;
338     int len, rsize, transform;
339
340     len = strlen(filename);
341     rsize = len + 1;
342     transform = (strstr(filename, "/") == NULL);
343     if (transform) {
344         /* We will convert this to "%s.so" or "lib%s.so" etc */
345         rsize += DSO_extlen;    /* The length of ".so" */
346         if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
347             rsize += 3;         /* The length of "lib" */
348     }
349     translated = OPENSSL_malloc(rsize);
350     if (translated == NULL) {
351         DSOerr(DSO_F_DLFCN_NAME_CONVERTER, DSO_R_NAME_TRANSLATION_FAILED);
352         return (NULL);
353     }
354     if (transform) {
355         if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
356             sprintf(translated, "lib%s" DSO_ext, filename);
357         else
358             sprintf(translated, "%s" DSO_ext, filename);
359     } else
360         sprintf(translated, "%s", filename);
361     return (translated);
362 }
363
364 # ifdef __sgi
365 /*-
366 This is a quote from IRIX manual for dladdr(3c):
367
368      <dlfcn.h> does not contain a prototype for dladdr or definition of
369      Dl_info.  The #include <dlfcn.h>  in the SYNOPSIS line is traditional,
370      but contains no dladdr prototype and no IRIX library contains an
371      implementation.  Write your own declaration based on the code below.
372
373      The following code is dependent on internal interfaces that are not
374      part of the IRIX compatibility guarantee; however, there is no future
375      intention to change this interface, so on a practical level, the code
376      below is safe to use on IRIX.
377 */
378 #  include <rld_interface.h>
379 #  ifndef _RLD_INTERFACE_DLFCN_H_DLADDR
380 #   define _RLD_INTERFACE_DLFCN_H_DLADDR
381 typedef struct Dl_info {
382     const char *dli_fname;
383     void *dli_fbase;
384     const char *dli_sname;
385     void *dli_saddr;
386     int dli_version;
387     int dli_reserved1;
388     long dli_reserved[4];
389 } Dl_info;
390 #  else
391 typedef struct Dl_info Dl_info;
392 #  endif
393 #  define _RLD_DLADDR             14
394
395 static int dladdr(void *address, Dl_info *dl)
396 {
397     void *v;
398     v = _rld_new_interface(_RLD_DLADDR, address, dl);
399     return (int)v;
400 }
401 # endif                         /* __sgi */
402
403 static int dlfcn_pathbyaddr(void *addr, char *path, int sz)
404 {
405 # ifdef HAVE_DLINFO
406     Dl_info dli;
407     int len;
408
409     if (addr == NULL) {
410         union {
411             int (*f) (void *, char *, int);
412             void *p;
413         } t = {
414             dlfcn_pathbyaddr
415         };
416         addr = t.p;
417     }
418
419     if (dladdr(addr, &dli)) {
420         len = (int)strlen(dli.dli_fname);
421         if (sz <= 0)
422             return len + 1;
423         if (len >= sz)
424             len = sz - 1;
425         memcpy(path, dli.dli_fname, len);
426         path[len++] = 0;
427         return len;
428     }
429
430     ERR_add_error_data(2, "dlfcn_pathbyaddr(): ", dlerror());
431 # endif
432     return -1;
433 }
434
435 static void *dlfcn_globallookup(const char *name)
436 {
437     void *ret = NULL, *handle = dlopen(NULL, RTLD_LAZY);
438
439     if (handle) {
440         ret = dlsym(handle, name);
441         dlclose(handle);
442     }
443
444     return ret;
445 }
446 #endif                          /* DSO_DLFCN */