|
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 © Portions copyright (c) 2006 Nokia Corporation. All rights reserved. |
|
60 */ |
|
61 |
|
62 |
|
63 #include <stdio.h> |
|
64 #include "cryptlib.h" |
|
65 #include <openssl/dso.h> |
|
66 #if (defined(SYMBIAN) && (defined(__WINSCW__) || defined(__WINS__))) |
|
67 #include "libcrypto_wsd_macros.h" |
|
68 #include "libcrypto_wsd.h" |
|
69 #endif |
|
70 |
|
71 #ifndef DSO_DLFCN |
|
72 DSO_METHOD *DSO_METHOD_dlfcn(void) |
|
73 { |
|
74 return NULL; |
|
75 } |
|
76 |
|
77 #else |
|
78 |
|
79 #ifdef HAVE_DLFCN_H |
|
80 #include <dlfcn.h> |
|
81 #endif |
|
82 |
|
83 /* Part of the hack in "dlfcn_load" ... */ |
|
84 #define DSO_MAX_TRANSLATED_SIZE 256 |
|
85 |
|
86 static int dlfcn_load(DSO *dso); |
|
87 static int dlfcn_unload(DSO *dso); |
|
88 static void *dlfcn_bind_var(DSO *dso, const char *symname); |
|
89 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname); |
|
90 #if 0 |
|
91 static int dlfcn_unbind(DSO *dso, char *symname, void *symptr); |
|
92 static int dlfcn_init(DSO *dso); |
|
93 static int dlfcn_finish(DSO *dso); |
|
94 static long dlfcn_ctrl(DSO *dso, int cmd, long larg, void *parg); |
|
95 #endif |
|
96 static char *dlfcn_name_converter(DSO *dso, const char *filename); |
|
97 static char *dlfcn_merger(DSO *dso, const char *filespec1, |
|
98 const char *filespec2); |
|
99 |
|
100 #ifndef EMULATOR |
|
101 static DSO_METHOD dso_meth_dlfcn = { |
|
102 "OpenSSL 'dlfcn' shared library method", |
|
103 dlfcn_load, |
|
104 dlfcn_unload, |
|
105 dlfcn_bind_var, |
|
106 dlfcn_bind_func, |
|
107 /* For now, "unbind" doesn't exist */ |
|
108 #if 0 |
|
109 NULL, /* unbind_var */ |
|
110 NULL, /* unbind_func */ |
|
111 #endif |
|
112 NULL, /* ctrl */ |
|
113 dlfcn_name_converter, |
|
114 dlfcn_merger, |
|
115 NULL, /* init */ |
|
116 NULL /* finish */ |
|
117 }; |
|
118 #else |
|
119 GET_STATIC_VAR_FROM_TLS(dso_meth_dlfcn,dso_dlfcn,DSO_METHOD) |
|
120 #define dso_meth_dlfcn (*GET_WSD_VAR_NAME(dso_meth_dlfcn,dso_dlfcn, s)()) |
|
121 const DSO_METHOD temp_s_dso_meth_dlfcn = { |
|
122 "OpenSSL 'dlfcn' shared library method", |
|
123 dlfcn_load, |
|
124 dlfcn_unload, |
|
125 dlfcn_bind_var, |
|
126 dlfcn_bind_func, |
|
127 /* For now, "unbind" doesn't exist */ |
|
128 #if 0 |
|
129 NULL, /* unbind_var */ |
|
130 NULL, /* unbind_func */ |
|
131 #endif |
|
132 NULL, /* ctrl */ |
|
133 dlfcn_name_converter, |
|
134 dlfcn_merger, |
|
135 NULL, /* init */ |
|
136 NULL /* finish */ |
|
137 }; |
|
138 |
|
139 #endif |
|
140 EXPORT_C DSO_METHOD *DSO_METHOD_dlfcn(void) |
|
141 { |
|
142 return(&dso_meth_dlfcn); |
|
143 } |
|
144 |
|
145 /* Prior to using the dlopen() function, we should decide on the flag |
|
146 * we send. There's a few different ways of doing this and it's a |
|
147 * messy venn-diagram to match up which platforms support what. So |
|
148 * as we don't have autoconf yet, I'm implementing a hack that could |
|
149 * be hacked further relatively easily to deal with cases as we find |
|
150 * them. Initially this is to cope with OpenBSD. */ |
|
151 #if defined(__OpenBSD__) || defined(__NetBSD__) |
|
152 # ifdef DL_LAZY |
|
153 # define DLOPEN_FLAG DL_LAZY |
|
154 # else |
|
155 # ifdef RTLD_NOW |
|
156 # define DLOPEN_FLAG RTLD_NOW |
|
157 # else |
|
158 # define DLOPEN_FLAG 0 |
|
159 # endif |
|
160 # endif |
|
161 #else |
|
162 # ifdef OPENSSL_SYS_SUNOS |
|
163 # define DLOPEN_FLAG 1 |
|
164 # else |
|
165 # define DLOPEN_FLAG RTLD_NOW /* Hope this works everywhere else */ |
|
166 # endif |
|
167 #endif |
|
168 |
|
169 /* For this DSO_METHOD, our meth_data STACK will contain; |
|
170 * (i) the handle (void*) returned from dlopen(). |
|
171 */ |
|
172 |
|
173 static int dlfcn_load(DSO *dso) |
|
174 { |
|
175 void *ptr = NULL; |
|
176 /* See applicable comments in dso_dl.c */ |
|
177 char *filename = DSO_convert_filename(dso, NULL); |
|
178 int flags = DLOPEN_FLAG; |
|
179 |
|
180 if(filename == NULL) |
|
181 { |
|
182 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_NO_FILENAME); |
|
183 goto err; |
|
184 } |
|
185 |
|
186 #ifdef RTLD_GLOBAL |
|
187 if (dso->flags & DSO_FLAG_GLOBAL_SYMBOLS) |
|
188 flags |= RTLD_GLOBAL; |
|
189 #endif |
|
190 ptr = dlopen(filename, flags); |
|
191 if(ptr == NULL) |
|
192 { |
|
193 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_LOAD_FAILED); |
|
194 ERR_add_error_data(4, "filename(", filename, "): ", dlerror()); |
|
195 goto err; |
|
196 } |
|
197 if(!sk_push(dso->meth_data, (char *)ptr)) |
|
198 { |
|
199 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_STACK_ERROR); |
|
200 goto err; |
|
201 } |
|
202 /* Success */ |
|
203 dso->loaded_filename = filename; |
|
204 return(1); |
|
205 err: |
|
206 /* Cleanup! */ |
|
207 if(filename != NULL) |
|
208 OPENSSL_free(filename); |
|
209 if(ptr != NULL) |
|
210 dlclose(ptr); |
|
211 return(0); |
|
212 } |
|
213 |
|
214 static int dlfcn_unload(DSO *dso) |
|
215 { |
|
216 void *ptr; |
|
217 if(dso == NULL) |
|
218 { |
|
219 DSOerr(DSO_F_DLFCN_UNLOAD,ERR_R_PASSED_NULL_PARAMETER); |
|
220 return(0); |
|
221 } |
|
222 if(sk_num(dso->meth_data) < 1) |
|
223 return(1); |
|
224 ptr = (void *)sk_pop(dso->meth_data); |
|
225 if(ptr == NULL) |
|
226 { |
|
227 DSOerr(DSO_F_DLFCN_UNLOAD,DSO_R_NULL_HANDLE); |
|
228 /* Should push the value back onto the stack in |
|
229 * case of a retry. */ |
|
230 sk_push(dso->meth_data, (char *)ptr); |
|
231 return(0); |
|
232 } |
|
233 /* For now I'm not aware of any errors associated with dlclose() */ |
|
234 dlclose(ptr); |
|
235 return(1); |
|
236 } |
|
237 |
|
238 static void *dlfcn_bind_var(DSO *dso, const char *symname) |
|
239 { |
|
240 void *ptr, *sym; |
|
241 |
|
242 if((dso == NULL) || (symname == NULL)) |
|
243 { |
|
244 DSOerr(DSO_F_DLFCN_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER); |
|
245 return(NULL); |
|
246 } |
|
247 if(sk_num(dso->meth_data) < 1) |
|
248 { |
|
249 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_STACK_ERROR); |
|
250 return(NULL); |
|
251 } |
|
252 ptr = (void *)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1); |
|
253 if(ptr == NULL) |
|
254 { |
|
255 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_NULL_HANDLE); |
|
256 return(NULL); |
|
257 } |
|
258 sym = dlsym(ptr, symname); |
|
259 if(sym == NULL) |
|
260 { |
|
261 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_SYM_FAILURE); |
|
262 ERR_add_error_data(4, "symname(", symname, "): ", dlerror()); |
|
263 return(NULL); |
|
264 } |
|
265 return(sym); |
|
266 } |
|
267 |
|
268 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname) |
|
269 { |
|
270 void *ptr; |
|
271 DSO_FUNC_TYPE sym, *tsym = &sym; |
|
272 |
|
273 if((dso == NULL) || (symname == NULL)) |
|
274 { |
|
275 DSOerr(DSO_F_DLFCN_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER); |
|
276 return(NULL); |
|
277 } |
|
278 if(sk_num(dso->meth_data) < 1) |
|
279 { |
|
280 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_STACK_ERROR); |
|
281 return(NULL); |
|
282 } |
|
283 ptr = (void *)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1); |
|
284 if(ptr == NULL) |
|
285 { |
|
286 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_NULL_HANDLE); |
|
287 return(NULL); |
|
288 } |
|
289 *(void **)(tsym) = dlsym(ptr, symname); |
|
290 if(sym == NULL) |
|
291 { |
|
292 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_SYM_FAILURE); |
|
293 ERR_add_error_data(4, "symname(", symname, "): ", dlerror()); |
|
294 return(NULL); |
|
295 } |
|
296 return(sym); |
|
297 } |
|
298 |
|
299 static char *dlfcn_merger(DSO *dso, const char *filespec1, |
|
300 const char *filespec2) |
|
301 { |
|
302 char *merged; |
|
303 |
|
304 if(!filespec1 && !filespec2) |
|
305 { |
|
306 DSOerr(DSO_F_DLFCN_MERGER, |
|
307 ERR_R_PASSED_NULL_PARAMETER); |
|
308 return(NULL); |
|
309 } |
|
310 /* If the first file specification is a rooted path, it rules. |
|
311 same goes if the second file specification is missing. */ |
|
312 if (!filespec2 || filespec1[0] == '/') |
|
313 { |
|
314 merged = OPENSSL_malloc(strlen(filespec1) + 1); |
|
315 if(!merged) |
|
316 { |
|
317 DSOerr(DSO_F_DLFCN_MERGER, |
|
318 ERR_R_MALLOC_FAILURE); |
|
319 return(NULL); |
|
320 } |
|
321 strcpy(merged, filespec1); |
|
322 } |
|
323 /* If the first file specification is missing, the second one rules. */ |
|
324 else if (!filespec1) |
|
325 { |
|
326 merged = OPENSSL_malloc(strlen(filespec2) + 1); |
|
327 if(!merged) |
|
328 { |
|
329 DSOerr(DSO_F_DLFCN_MERGER, |
|
330 ERR_R_MALLOC_FAILURE); |
|
331 return(NULL); |
|
332 } |
|
333 strcpy(merged, filespec2); |
|
334 } |
|
335 else |
|
336 /* This part isn't as trivial as it looks. It assumes that |
|
337 the second file specification really is a directory, and |
|
338 makes no checks whatsoever. Therefore, the result becomes |
|
339 the concatenation of filespec2 followed by a slash followed |
|
340 by filespec1. */ |
|
341 { |
|
342 int spec2len, len; |
|
343 |
|
344 spec2len = (filespec2 ? strlen(filespec2) : 0); |
|
345 len = spec2len + (filespec1 ? strlen(filespec1) : 0); |
|
346 |
|
347 if(filespec2 && filespec2[spec2len - 1] == '/') |
|
348 { |
|
349 spec2len--; |
|
350 len--; |
|
351 } |
|
352 merged = OPENSSL_malloc(len + 2); |
|
353 if(!merged) |
|
354 { |
|
355 DSOerr(DSO_F_DLFCN_MERGER, |
|
356 ERR_R_MALLOC_FAILURE); |
|
357 return(NULL); |
|
358 } |
|
359 strcpy(merged, filespec2); |
|
360 merged[spec2len] = '/'; |
|
361 strcpy(&merged[spec2len + 1], filespec1); |
|
362 } |
|
363 return(merged); |
|
364 } |
|
365 |
|
366 static char *dlfcn_name_converter(DSO *dso, const char *filename) |
|
367 { |
|
368 char *translated; |
|
369 int len, rsize, transform; |
|
370 |
|
371 len = strlen(filename); |
|
372 rsize = len + 1; |
|
373 transform = (strstr(filename, "/") == NULL); |
|
374 if(transform) |
|
375 { |
|
376 #ifndef SYMBIAN |
|
377 /* We will convert this to "%s.so" or "lib%s.so" */ |
|
378 rsize += 3; /* The length of ".so" */ |
|
379 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0) |
|
380 rsize += 3; /* The length of "lib" */ |
|
381 #else |
|
382 /* We will convert this to "%s.dll" or "lib%s.dll" */ |
|
383 rsize += 4; /* The length of ".dll" */ |
|
384 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0) |
|
385 rsize += 3; /* The length of "lib" */ |
|
386 #endif |
|
387 } |
|
388 translated = OPENSSL_malloc(rsize); |
|
389 if(translated == NULL) |
|
390 { |
|
391 DSOerr(DSO_F_DLFCN_NAME_CONVERTER, |
|
392 DSO_R_NAME_TRANSLATION_FAILED); |
|
393 return(NULL); |
|
394 } |
|
395 if(transform) |
|
396 { |
|
397 #ifndef SYMBIAN |
|
398 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0) |
|
399 sprintf(translated, "lib%s.so", filename); |
|
400 else |
|
401 sprintf(translated, "%s.so", filename); |
|
402 #else |
|
403 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0) |
|
404 sprintf(translated, "lib%s.dll", filename); |
|
405 else |
|
406 sprintf(translated, "%s.dll", filename); |
|
407 |
|
408 #endif |
|
409 |
|
410 } |
|
411 else |
|
412 sprintf(translated, "%s", filename); |
|
413 return(translated); |
|
414 } |
|
415 |
|
416 #endif /* DSO_DLFCN */ |