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