diff options
Diffstat (limited to 'src/lib/libcrypto/dso/dso_dlfcn.c')
-rw-r--r-- | src/lib/libcrypto/dso/dso_dlfcn.c | 293 |
1 files changed, 293 insertions, 0 deletions
diff --git a/src/lib/libcrypto/dso/dso_dlfcn.c b/src/lib/libcrypto/dso/dso_dlfcn.c new file mode 100644 index 0000000000..2e72969431 --- /dev/null +++ b/src/lib/libcrypto/dso/dso_dlfcn.c | |||
@@ -0,0 +1,293 @@ | |||
1 | /* dso_dlfcn.c */ | ||
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 | #include <stdio.h> | ||
60 | #include "cryptlib.h" | ||
61 | #include <openssl/dso.h> | ||
62 | |||
63 | #ifndef DSO_DLFCN | ||
64 | DSO_METHOD *DSO_METHOD_dlfcn(void) | ||
65 | { | ||
66 | return NULL; | ||
67 | } | ||
68 | #else | ||
69 | |||
70 | #ifdef HAVE_DLFCN_H | ||
71 | #include <dlfcn.h> | ||
72 | #endif | ||
73 | |||
74 | /* Part of the hack in "dlfcn_load" ... */ | ||
75 | #define DSO_MAX_TRANSLATED_SIZE 256 | ||
76 | |||
77 | static int dlfcn_load(DSO *dso); | ||
78 | static int dlfcn_unload(DSO *dso); | ||
79 | static void *dlfcn_bind_var(DSO *dso, const char *symname); | ||
80 | static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname); | ||
81 | #if 0 | ||
82 | static int dlfcn_unbind(DSO *dso, char *symname, void *symptr); | ||
83 | static int dlfcn_init(DSO *dso); | ||
84 | static int dlfcn_finish(DSO *dso); | ||
85 | static long dlfcn_ctrl(DSO *dso, int cmd, long larg, void *parg); | ||
86 | #endif | ||
87 | static char *dlfcn_name_converter(DSO *dso, const char *filename); | ||
88 | |||
89 | static DSO_METHOD dso_meth_dlfcn = { | ||
90 | "OpenSSL 'dlfcn' shared library method", | ||
91 | dlfcn_load, | ||
92 | dlfcn_unload, | ||
93 | dlfcn_bind_var, | ||
94 | dlfcn_bind_func, | ||
95 | /* For now, "unbind" doesn't exist */ | ||
96 | #if 0 | ||
97 | NULL, /* unbind_var */ | ||
98 | NULL, /* unbind_func */ | ||
99 | #endif | ||
100 | NULL, /* ctrl */ | ||
101 | dlfcn_name_converter, | ||
102 | NULL, /* init */ | ||
103 | NULL /* finish */ | ||
104 | }; | ||
105 | |||
106 | DSO_METHOD *DSO_METHOD_dlfcn(void) | ||
107 | { | ||
108 | return(&dso_meth_dlfcn); | ||
109 | } | ||
110 | |||
111 | /* Prior to using the dlopen() function, we should decide on the flag | ||
112 | * we send. There's a few different ways of doing this and it's a | ||
113 | * messy venn-diagram to match up which platforms support what. So | ||
114 | * as we don't have autoconf yet, I'm implementing a hack that could | ||
115 | * be hacked further relatively easily to deal with cases as we find | ||
116 | * them. Initially this is to cope with OpenBSD. */ | ||
117 | #if defined(__OpenBSD__) || defined(__NetBSD__) | ||
118 | # ifdef DL_LAZY | ||
119 | # define DLOPEN_FLAG DL_LAZY | ||
120 | # else | ||
121 | # ifdef RTLD_NOW | ||
122 | # define DLOPEN_FLAG RTLD_NOW | ||
123 | # else | ||
124 | # define DLOPEN_FLAG 0 | ||
125 | # endif | ||
126 | # endif | ||
127 | #else | ||
128 | # ifdef OPENSSL_SYS_SUNOS | ||
129 | # define DLOPEN_FLAG 1 | ||
130 | # else | ||
131 | # define DLOPEN_FLAG RTLD_NOW /* Hope this works everywhere else */ | ||
132 | # endif | ||
133 | #endif | ||
134 | |||
135 | /* For this DSO_METHOD, our meth_data STACK will contain; | ||
136 | * (i) the handle (void*) returned from dlopen(). | ||
137 | */ | ||
138 | |||
139 | static int dlfcn_load(DSO *dso) | ||
140 | { | ||
141 | void *ptr = NULL; | ||
142 | /* See applicable comments in dso_dl.c */ | ||
143 | char *filename = DSO_convert_filename(dso, NULL); | ||
144 | |||
145 | if(filename == NULL) | ||
146 | { | ||
147 | DSOerr(DSO_F_DLFCN_LOAD,DSO_R_NO_FILENAME); | ||
148 | goto err; | ||
149 | } | ||
150 | ptr = dlopen(filename, DLOPEN_FLAG); | ||
151 | if(ptr == NULL) | ||
152 | { | ||
153 | DSOerr(DSO_F_DLFCN_LOAD,DSO_R_LOAD_FAILED); | ||
154 | ERR_add_error_data(4, "filename(", filename, "): ", dlerror()); | ||
155 | goto err; | ||
156 | } | ||
157 | if(!sk_push(dso->meth_data, (char *)ptr)) | ||
158 | { | ||
159 | DSOerr(DSO_F_DLFCN_LOAD,DSO_R_STACK_ERROR); | ||
160 | goto err; | ||
161 | } | ||
162 | /* Success */ | ||
163 | dso->loaded_filename = filename; | ||
164 | return(1); | ||
165 | err: | ||
166 | /* Cleanup! */ | ||
167 | if(filename != NULL) | ||
168 | OPENSSL_free(filename); | ||
169 | if(ptr != NULL) | ||
170 | dlclose(ptr); | ||
171 | return(0); | ||
172 | } | ||
173 | |||
174 | static int dlfcn_unload(DSO *dso) | ||
175 | { | ||
176 | void *ptr; | ||
177 | if(dso == NULL) | ||
178 | { | ||
179 | DSOerr(DSO_F_DLFCN_UNLOAD,ERR_R_PASSED_NULL_PARAMETER); | ||
180 | return(0); | ||
181 | } | ||
182 | if(sk_num(dso->meth_data) < 1) | ||
183 | return(1); | ||
184 | ptr = (void *)sk_pop(dso->meth_data); | ||
185 | if(ptr == NULL) | ||
186 | { | ||
187 | DSOerr(DSO_F_DLFCN_UNLOAD,DSO_R_NULL_HANDLE); | ||
188 | /* Should push the value back onto the stack in | ||
189 | * case of a retry. */ | ||
190 | sk_push(dso->meth_data, (char *)ptr); | ||
191 | return(0); | ||
192 | } | ||
193 | /* For now I'm not aware of any errors associated with dlclose() */ | ||
194 | dlclose(ptr); | ||
195 | return(1); | ||
196 | } | ||
197 | |||
198 | static void *dlfcn_bind_var(DSO *dso, const char *symname) | ||
199 | { | ||
200 | void *ptr, *sym; | ||
201 | |||
202 | if((dso == NULL) || (symname == NULL)) | ||
203 | { | ||
204 | DSOerr(DSO_F_DLFCN_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER); | ||
205 | return(NULL); | ||
206 | } | ||
207 | if(sk_num(dso->meth_data) < 1) | ||
208 | { | ||
209 | DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_STACK_ERROR); | ||
210 | return(NULL); | ||
211 | } | ||
212 | ptr = (void *)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1); | ||
213 | if(ptr == NULL) | ||
214 | { | ||
215 | DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_NULL_HANDLE); | ||
216 | return(NULL); | ||
217 | } | ||
218 | sym = dlsym(ptr, symname); | ||
219 | if(sym == NULL) | ||
220 | { | ||
221 | DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_SYM_FAILURE); | ||
222 | ERR_add_error_data(4, "symname(", symname, "): ", dlerror()); | ||
223 | return(NULL); | ||
224 | } | ||
225 | return(sym); | ||
226 | } | ||
227 | |||
228 | static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname) | ||
229 | { | ||
230 | void *ptr; | ||
231 | DSO_FUNC_TYPE sym; | ||
232 | |||
233 | if((dso == NULL) || (symname == NULL)) | ||
234 | { | ||
235 | DSOerr(DSO_F_DLFCN_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER); | ||
236 | return(NULL); | ||
237 | } | ||
238 | if(sk_num(dso->meth_data) < 1) | ||
239 | { | ||
240 | DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_STACK_ERROR); | ||
241 | return(NULL); | ||
242 | } | ||
243 | ptr = (void *)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1); | ||
244 | if(ptr == NULL) | ||
245 | { | ||
246 | DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_NULL_HANDLE); | ||
247 | return(NULL); | ||
248 | } | ||
249 | sym = (DSO_FUNC_TYPE)dlsym(ptr, symname); | ||
250 | if(sym == NULL) | ||
251 | { | ||
252 | DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_SYM_FAILURE); | ||
253 | ERR_add_error_data(4, "symname(", symname, "): ", dlerror()); | ||
254 | return(NULL); | ||
255 | } | ||
256 | return(sym); | ||
257 | } | ||
258 | |||
259 | static char *dlfcn_name_converter(DSO *dso, const char *filename) | ||
260 | { | ||
261 | char *translated; | ||
262 | int len, rsize, transform; | ||
263 | |||
264 | len = strlen(filename); | ||
265 | rsize = len + 1; | ||
266 | transform = (strstr(filename, "/") == NULL); | ||
267 | if(transform) | ||
268 | { | ||
269 | /* We will convert this to "%s.so" or "lib%s.so" */ | ||
270 | rsize += 3; /* The length of ".so" */ | ||
271 | if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0) | ||
272 | rsize += 3; /* The length of "lib" */ | ||
273 | } | ||
274 | translated = OPENSSL_malloc(rsize); | ||
275 | if(translated == NULL) | ||
276 | { | ||
277 | DSOerr(DSO_F_DLFCN_NAME_CONVERTER, | ||
278 | DSO_R_NAME_TRANSLATION_FAILED); | ||
279 | return(NULL); | ||
280 | } | ||
281 | if(transform) | ||
282 | { | ||
283 | if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0) | ||
284 | snprintf(translated, rsize, "lib%s.so", filename); | ||
285 | else | ||
286 | snprintf(translated, rsize, "%s.so", filename); | ||
287 | } | ||
288 | else | ||
289 | snprintf(translated, rsize, "%s", filename); | ||
290 | return(translated); | ||
291 | } | ||
292 | |||
293 | #endif /* DSO_DLFCN */ | ||