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