d9898ee8 |
1 | /* ltdl.c -- system independent dlopen wrapper |
ac40fd9e |
2 | Copyright (C) 1998, 1999, 2000, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. |
d9898ee8 |
3 | Originally by Thomas Tanner <tanner@ffii.org> |
4 | This file is part of GNU Libtool. |
5 | |
6 | This library is free software; you can redistribute it and/or |
7 | modify it under the terms of the GNU Lesser General Public |
8 | License as published by the Free Software Foundation; either |
9 | version 2 of the License, or (at your option) any later version. |
10 | |
11 | As a special exception to the GNU Lesser General Public License, |
12 | if you distribute this file as part of a program or library that |
13 | is built using GNU libtool, you may include it under the same |
14 | distribution terms that you use for the rest of that program. |
15 | |
16 | This library is distributed in the hope that it will be useful, |
17 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
18 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
19 | Lesser General Public License for more details. |
20 | |
21 | You should have received a copy of the GNU Lesser General Public |
22 | License along with this library; if not, write to the Free Software |
23 | Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
24 | 02110-1301 USA |
25 | |
26 | */ |
27 | |
28 | #if HAVE_CONFIG_H |
29 | # include <config.h> |
30 | #endif |
31 | |
32 | #if HAVE_UNISTD_H |
33 | # include <unistd.h> |
34 | #endif |
35 | |
36 | #if HAVE_STDIO_H |
37 | # include <stdio.h> |
38 | #endif |
39 | |
40 | /* Include the header defining malloc. On K&R C compilers, |
41 | that's <malloc.h>, on ANSI C and ISO C compilers, that's <stdlib.h>. */ |
42 | #if HAVE_STDLIB_H |
43 | # include <stdlib.h> |
44 | #else |
45 | # if HAVE_MALLOC_H |
46 | # include <malloc.h> |
47 | # endif |
48 | #endif |
49 | |
50 | #if HAVE_STRING_H |
51 | # include <string.h> |
52 | #else |
53 | # if HAVE_STRINGS_H |
54 | # include <strings.h> |
55 | # endif |
56 | #endif |
57 | |
58 | #if HAVE_CTYPE_H |
59 | # include <ctype.h> |
60 | #endif |
61 | |
62 | #if HAVE_MEMORY_H |
63 | # include <memory.h> |
64 | #endif |
65 | |
66 | #if HAVE_ERRNO_H |
67 | # include <errno.h> |
68 | #endif |
69 | |
70 | |
71 | #ifndef __WINDOWS__ |
72 | # ifdef __WIN32__ |
73 | # define __WINDOWS__ |
74 | # endif |
75 | #endif |
76 | |
77 | |
78 | #undef LT_USE_POSIX_DIRENT |
79 | #ifdef HAVE_CLOSEDIR |
80 | # ifdef HAVE_OPENDIR |
81 | # ifdef HAVE_READDIR |
82 | # ifdef HAVE_DIRENT_H |
83 | # define LT_USE_POSIX_DIRENT |
84 | # endif /* HAVE_DIRENT_H */ |
85 | # endif /* HAVE_READDIR */ |
86 | # endif /* HAVE_OPENDIR */ |
87 | #endif /* HAVE_CLOSEDIR */ |
88 | |
89 | |
90 | #undef LT_USE_WINDOWS_DIRENT_EMULATION |
91 | #ifndef LT_USE_POSIX_DIRENT |
92 | # ifdef __WINDOWS__ |
93 | # define LT_USE_WINDOWS_DIRENT_EMULATION |
94 | # endif /* __WINDOWS__ */ |
95 | #endif /* LT_USE_POSIX_DIRENT */ |
96 | |
97 | |
98 | #ifdef LT_USE_POSIX_DIRENT |
99 | # include <dirent.h> |
100 | # define LT_D_NAMLEN(dirent) (strlen((dirent)->d_name)) |
101 | #else |
102 | # ifdef LT_USE_WINDOWS_DIRENT_EMULATION |
103 | # define LT_D_NAMLEN(dirent) (strlen((dirent)->d_name)) |
104 | # else |
105 | # define dirent direct |
106 | # define LT_D_NAMLEN(dirent) ((dirent)->d_namlen) |
107 | # if HAVE_SYS_NDIR_H |
108 | # include <sys/ndir.h> |
109 | # endif |
110 | # if HAVE_SYS_DIR_H |
111 | # include <sys/dir.h> |
112 | # endif |
113 | # if HAVE_NDIR_H |
114 | # include <ndir.h> |
115 | # endif |
116 | # endif |
117 | #endif |
118 | |
119 | #if HAVE_ARGZ_H |
120 | # include <argz.h> |
121 | #endif |
122 | |
123 | #if HAVE_ASSERT_H |
124 | # include <assert.h> |
125 | #else |
126 | # define assert(arg) ((void) 0) |
127 | #endif |
128 | |
129 | #include "ltdl.h" |
130 | |
131 | #if WITH_DMALLOC |
132 | # include <dmalloc.h> |
133 | #endif |
134 | |
135 | |
136 | |
137 | \f |
138 | /* --- WINDOWS SUPPORT --- */ |
139 | |
ac40fd9e |
140 | /* DLL building support on win32 hosts; mostly to workaround their |
141 | ridiculous implementation of data symbol exporting. */ |
142 | #ifndef LT_GLOBAL_DATA |
143 | # if defined(__WINDOWS__) || defined(__CYGWIN__) |
144 | # ifdef DLL_EXPORT /* defined by libtool (if required) */ |
145 | # define LT_GLOBAL_DATA __declspec(dllexport) |
146 | # endif |
147 | # endif |
148 | # ifndef LT_GLOBAL_DATA /* static linking or !__WINDOWS__ */ |
149 | # define LT_GLOBAL_DATA |
150 | # endif |
d9898ee8 |
151 | #endif |
152 | |
153 | /* fopen() mode flags for reading a text file */ |
154 | #undef LT_READTEXT_MODE |
ac40fd9e |
155 | #if defined(__WINDOWS__) || defined(__CYGWIN__) |
d9898ee8 |
156 | # define LT_READTEXT_MODE "rt" |
157 | #else |
158 | # define LT_READTEXT_MODE "r" |
159 | #endif |
160 | |
161 | #ifdef LT_USE_WINDOWS_DIRENT_EMULATION |
162 | |
163 | #include <windows.h> |
164 | |
165 | #define dirent lt_dirent |
166 | #define DIR lt_DIR |
167 | |
168 | struct dirent |
169 | { |
170 | char d_name[2048]; |
171 | int d_namlen; |
172 | }; |
173 | |
174 | typedef struct _DIR |
175 | { |
176 | HANDLE hSearch; |
177 | WIN32_FIND_DATA Win32FindData; |
178 | BOOL firsttime; |
179 | struct dirent file_info; |
180 | } DIR; |
181 | |
182 | #endif /* LT_USE_WINDOWS_DIRENT_EMULATION */ |
183 | |
184 | \f |
185 | /* --- MANIFEST CONSTANTS --- */ |
186 | |
187 | |
188 | /* Standard libltdl search path environment variable name */ |
189 | #undef LTDL_SEARCHPATH_VAR |
190 | #define LTDL_SEARCHPATH_VAR "LTDL_LIBRARY_PATH" |
191 | |
192 | /* Standard libtool archive file extension. */ |
193 | #undef LTDL_ARCHIVE_EXT |
194 | #define LTDL_ARCHIVE_EXT ".la" |
195 | |
196 | /* max. filename length */ |
197 | #ifndef LT_FILENAME_MAX |
198 | # define LT_FILENAME_MAX 1024 |
199 | #endif |
200 | |
201 | /* This is the maximum symbol size that won't require malloc/free */ |
202 | #undef LT_SYMBOL_LENGTH |
203 | #define LT_SYMBOL_LENGTH 128 |
204 | |
205 | /* This accounts for the _LTX_ separator */ |
206 | #undef LT_SYMBOL_OVERHEAD |
207 | #define LT_SYMBOL_OVERHEAD 5 |
208 | |
209 | |
210 | |
211 | \f |
212 | /* --- MEMORY HANDLING --- */ |
213 | |
214 | |
215 | /* These are the functions used internally. In addition to making |
216 | use of the associated function pointers above, they also perform |
217 | error handling. */ |
218 | static char *lt_estrdup LT_PARAMS((const char *str)); |
219 | static lt_ptr lt_emalloc LT_PARAMS((size_t size)); |
220 | static lt_ptr lt_erealloc LT_PARAMS((lt_ptr addr, size_t size)); |
221 | |
222 | /* static lt_ptr rpl_realloc LT_PARAMS((lt_ptr ptr, size_t size)); */ |
223 | #define rpl_realloc realloc |
224 | |
225 | /* These are the pointers that can be changed by the caller: */ |
226 | LT_GLOBAL_DATA lt_ptr (*lt_dlmalloc) LT_PARAMS((size_t size)) |
227 | = (lt_ptr (*) LT_PARAMS((size_t))) malloc; |
228 | LT_GLOBAL_DATA lt_ptr (*lt_dlrealloc) LT_PARAMS((lt_ptr ptr, size_t size)) |
229 | = (lt_ptr (*) LT_PARAMS((lt_ptr, size_t))) rpl_realloc; |
230 | LT_GLOBAL_DATA void (*lt_dlfree) LT_PARAMS((lt_ptr ptr)) |
231 | = (void (*) LT_PARAMS((lt_ptr))) free; |
232 | |
233 | /* The following macros reduce the amount of typing needed to cast |
234 | assigned memory. */ |
235 | #if WITH_DMALLOC |
236 | |
237 | #define LT_DLMALLOC(tp, n) ((tp *) xmalloc ((n) * sizeof(tp))) |
238 | #define LT_DLREALLOC(tp, p, n) ((tp *) xrealloc ((p), (n) * sizeof(tp))) |
239 | #define LT_DLFREE(p) \ |
240 | LT_STMT_START { if (p) (p) = (xfree (p), (lt_ptr) 0); } LT_STMT_END |
241 | |
242 | #define LT_EMALLOC(tp, n) ((tp *) xmalloc ((n) * sizeof(tp))) |
243 | #define LT_EREALLOC(tp, p, n) ((tp *) xrealloc ((p), (n) * sizeof(tp))) |
244 | |
245 | #else |
246 | |
247 | #define LT_DLMALLOC(tp, n) ((tp *) lt_dlmalloc ((n) * sizeof(tp))) |
248 | #define LT_DLREALLOC(tp, p, n) ((tp *) lt_dlrealloc ((p), (n) * sizeof(tp))) |
249 | #define LT_DLFREE(p) \ |
250 | LT_STMT_START { if (p) (p) = (lt_dlfree (p), (lt_ptr) 0); } LT_STMT_END |
251 | |
252 | #define LT_EMALLOC(tp, n) ((tp *) lt_emalloc ((n) * sizeof(tp))) |
253 | #define LT_EREALLOC(tp, p, n) ((tp *) lt_erealloc ((p), (n) * sizeof(tp))) |
254 | |
255 | #endif |
256 | |
257 | #define LT_DLMEM_REASSIGN(p, q) LT_STMT_START { \ |
258 | if ((p) != (q)) { if (p) lt_dlfree (p); (p) = (q); (q) = 0; } \ |
259 | } LT_STMT_END |
260 | |
261 | \f |
262 | /* --- REPLACEMENT FUNCTIONS --- */ |
263 | |
264 | |
265 | #undef strdup |
266 | #define strdup rpl_strdup |
267 | |
268 | static char *strdup LT_PARAMS((const char *str)); |
269 | |
270 | static char * |
271 | strdup(str) |
272 | const char *str; |
273 | { |
274 | char *tmp = 0; |
275 | |
276 | if (str) |
277 | { |
278 | tmp = LT_DLMALLOC (char, 1+ strlen (str)); |
279 | if (tmp) |
280 | { |
281 | strcpy(tmp, str); |
282 | } |
283 | } |
284 | |
285 | return tmp; |
286 | } |
287 | |
288 | |
289 | #if ! HAVE_STRCMP |
290 | |
291 | #undef strcmp |
292 | #define strcmp rpl_strcmp |
293 | |
294 | static int strcmp LT_PARAMS((const char *str1, const char *str2)); |
295 | |
296 | static int |
297 | strcmp (str1, str2) |
298 | const char *str1; |
299 | const char *str2; |
300 | { |
301 | if (str1 == str2) |
302 | return 0; |
303 | if (str1 == 0) |
304 | return -1; |
305 | if (str2 == 0) |
306 | return 1; |
307 | |
308 | for (;*str1 && *str2; ++str1, ++str2) |
309 | { |
310 | if (*str1 != *str2) |
311 | break; |
312 | } |
313 | |
314 | return (int)(*str1 - *str2); |
315 | } |
316 | #endif |
317 | |
318 | |
319 | #if ! HAVE_STRCHR |
320 | |
321 | # if HAVE_INDEX |
322 | # define strchr index |
323 | # else |
324 | # define strchr rpl_strchr |
325 | |
326 | static const char *strchr LT_PARAMS((const char *str, int ch)); |
327 | |
328 | static const char* |
329 | strchr(str, ch) |
330 | const char *str; |
331 | int ch; |
332 | { |
333 | const char *p; |
334 | |
335 | for (p = str; *p != (char)ch && *p != LT_EOS_CHAR; ++p) |
336 | /*NOWORK*/; |
337 | |
338 | return (*p == (char)ch) ? p : 0; |
339 | } |
340 | |
341 | # endif |
342 | #endif /* !HAVE_STRCHR */ |
343 | |
344 | |
345 | #if ! HAVE_STRRCHR |
346 | |
347 | # if HAVE_RINDEX |
348 | # define strrchr rindex |
349 | # else |
350 | # define strrchr rpl_strrchr |
351 | |
352 | static const char *strrchr LT_PARAMS((const char *str, int ch)); |
353 | |
354 | static const char* |
355 | strrchr(str, ch) |
356 | const char *str; |
357 | int ch; |
358 | { |
359 | const char *p, *q = 0; |
360 | |
361 | for (p = str; *p != LT_EOS_CHAR; ++p) |
362 | { |
363 | if (*p == (char) ch) |
364 | { |
365 | q = p; |
366 | } |
367 | } |
368 | |
369 | return q; |
370 | } |
371 | |
372 | # endif |
373 | #endif |
374 | |
375 | /* NOTE: Neither bcopy nor the memcpy implementation below can |
376 | reliably handle copying in overlapping areas of memory. Use |
377 | memmove (for which there is a fallback implmentation below) |
378 | if you need that behaviour. */ |
379 | #if ! HAVE_MEMCPY |
380 | |
381 | # if HAVE_BCOPY |
382 | # define memcpy(dest, src, size) bcopy (src, dest, size) |
383 | # else |
384 | # define memcpy rpl_memcpy |
385 | |
386 | static lt_ptr memcpy LT_PARAMS((lt_ptr dest, const lt_ptr src, size_t size)); |
387 | |
388 | static lt_ptr |
389 | memcpy (dest, src, size) |
390 | lt_ptr dest; |
391 | const lt_ptr src; |
392 | size_t size; |
393 | { |
394 | const char * s = src; |
395 | char * d = dest; |
396 | size_t i = 0; |
397 | |
398 | for (i = 0; i < size; ++i) |
399 | { |
400 | d[i] = s[i]; |
401 | } |
402 | |
403 | return dest; |
404 | } |
405 | |
406 | # endif /* !HAVE_BCOPY */ |
407 | #endif /* !HAVE_MEMCPY */ |
408 | |
409 | #if ! HAVE_MEMMOVE |
410 | # define memmove rpl_memmove |
411 | |
412 | static lt_ptr memmove LT_PARAMS((lt_ptr dest, const lt_ptr src, size_t size)); |
413 | |
414 | static lt_ptr |
415 | memmove (dest, src, size) |
416 | lt_ptr dest; |
417 | const lt_ptr src; |
418 | size_t size; |
419 | { |
420 | const char * s = src; |
421 | char * d = dest; |
422 | size_t i; |
423 | |
424 | if (d < s) |
425 | for (i = 0; i < size; ++i) |
426 | { |
427 | d[i] = s[i]; |
428 | } |
429 | else if (d > s && size > 0) |
430 | for (i = size -1; ; --i) |
431 | { |
432 | d[i] = s[i]; |
433 | if (i == 0) |
434 | break; |
435 | } |
436 | |
437 | return dest; |
438 | } |
439 | |
440 | #endif /* !HAVE_MEMMOVE */ |
441 | |
442 | #ifdef LT_USE_WINDOWS_DIRENT_EMULATION |
443 | |
444 | static void closedir LT_PARAMS((DIR *entry)); |
445 | |
446 | static void |
447 | closedir(entry) |
448 | DIR *entry; |
449 | { |
450 | assert(entry != (DIR *) NULL); |
451 | FindClose(entry->hSearch); |
452 | lt_dlfree((lt_ptr)entry); |
453 | } |
454 | |
455 | |
456 | static DIR * opendir LT_PARAMS((const char *path)); |
457 | |
458 | static DIR* |
459 | opendir (path) |
460 | const char *path; |
461 | { |
462 | char file_specification[LT_FILENAME_MAX]; |
463 | DIR *entry; |
464 | |
465 | assert(path != (char *) NULL); |
466 | /* allow space for: path + '\\' '\\' '*' '.' '*' + '\0' */ |
467 | (void) strncpy (file_specification, path, LT_FILENAME_MAX-6); |
468 | file_specification[LT_FILENAME_MAX-6] = LT_EOS_CHAR; |
469 | (void) strcat(file_specification,"\\"); |
470 | entry = LT_DLMALLOC (DIR,sizeof(DIR)); |
471 | if (entry != (DIR *) 0) |
472 | { |
473 | entry->firsttime = TRUE; |
474 | entry->hSearch = FindFirstFile(file_specification,&entry->Win32FindData); |
475 | } |
476 | if (entry->hSearch == INVALID_HANDLE_VALUE) |
477 | { |
478 | (void) strcat(file_specification,"\\*.*"); |
479 | entry->hSearch = FindFirstFile(file_specification,&entry->Win32FindData); |
480 | if (entry->hSearch == INVALID_HANDLE_VALUE) |
481 | { |
482 | LT_DLFREE (entry); |
483 | return (DIR *) 0; |
484 | } |
485 | } |
486 | return(entry); |
487 | } |
488 | |
489 | |
490 | static struct dirent *readdir LT_PARAMS((DIR *entry)); |
491 | |
492 | static struct dirent *readdir(entry) |
493 | DIR *entry; |
494 | { |
495 | int |
496 | status; |
497 | |
498 | if (entry == (DIR *) 0) |
499 | return((struct dirent *) 0); |
500 | if (!entry->firsttime) |
501 | { |
502 | status = FindNextFile(entry->hSearch,&entry->Win32FindData); |
503 | if (status == 0) |
504 | return((struct dirent *) 0); |
505 | } |
506 | entry->firsttime = FALSE; |
507 | (void) strncpy(entry->file_info.d_name,entry->Win32FindData.cFileName, |
508 | LT_FILENAME_MAX-1); |
509 | entry->file_info.d_name[LT_FILENAME_MAX - 1] = LT_EOS_CHAR; |
510 | entry->file_info.d_namlen = strlen(entry->file_info.d_name); |
511 | return(&entry->file_info); |
512 | } |
513 | |
514 | #endif /* LT_USE_WINDOWS_DIRENT_EMULATION */ |
515 | |
516 | /* According to Alexandre Oliva <oliva@lsd.ic.unicamp.br>, |
517 | ``realloc is not entirely portable'' |
518 | In any case we want to use the allocator supplied by the user without |
519 | burdening them with an lt_dlrealloc function pointer to maintain. |
520 | Instead implement our own version (with known boundary conditions) |
521 | using lt_dlmalloc and lt_dlfree. */ |
522 | |
523 | /* #undef realloc |
524 | #define realloc rpl_realloc |
525 | */ |
526 | #if 0 |
527 | /* You can't (re)define realloc unless you also (re)define malloc. |
528 | Right now, this code uses the size of the *destination* to decide |
529 | how much to copy. That's not right, but you can't know the size |
530 | of the source unless you know enough about, or wrote malloc. So |
531 | this code is disabled... */ |
532 | |
533 | static lt_ptr |
534 | realloc (ptr, size) |
535 | lt_ptr ptr; |
536 | size_t size; |
537 | { |
538 | if (size == 0) |
539 | { |
540 | /* For zero or less bytes, free the original memory */ |
541 | if (ptr != 0) |
542 | { |
543 | lt_dlfree (ptr); |
544 | } |
545 | |
546 | return (lt_ptr) 0; |
547 | } |
548 | else if (ptr == 0) |
549 | { |
550 | /* Allow reallocation of a NULL pointer. */ |
551 | return lt_dlmalloc (size); |
552 | } |
553 | else |
554 | { |
555 | /* Allocate a new block, copy and free the old block. */ |
556 | lt_ptr mem = lt_dlmalloc (size); |
557 | |
558 | if (mem) |
559 | { |
560 | memcpy (mem, ptr, size); |
561 | lt_dlfree (ptr); |
562 | } |
563 | |
564 | /* Note that the contents of PTR are not damaged if there is |
565 | insufficient memory to realloc. */ |
566 | return mem; |
567 | } |
568 | } |
569 | #endif |
570 | |
571 | |
572 | #if ! HAVE_ARGZ_APPEND |
573 | # define argz_append rpl_argz_append |
574 | |
575 | static error_t argz_append LT_PARAMS((char **pargz, size_t *pargz_len, |
576 | const char *buf, size_t buf_len)); |
577 | |
578 | static error_t |
579 | argz_append (pargz, pargz_len, buf, buf_len) |
580 | char **pargz; |
581 | size_t *pargz_len; |
582 | const char *buf; |
583 | size_t buf_len; |
584 | { |
585 | size_t argz_len; |
586 | char *argz; |
587 | |
588 | assert (pargz); |
589 | assert (pargz_len); |
590 | assert ((*pargz && *pargz_len) || (!*pargz && !*pargz_len)); |
591 | |
592 | /* If nothing needs to be appended, no more work is required. */ |
593 | if (buf_len == 0) |
594 | return 0; |
595 | |
596 | /* Ensure there is enough room to append BUF_LEN. */ |
597 | argz_len = *pargz_len + buf_len; |
598 | argz = LT_DLREALLOC (char, *pargz, argz_len); |
599 | if (!argz) |
600 | return ENOMEM; |
601 | |
602 | /* Copy characters from BUF after terminating '\0' in ARGZ. */ |
603 | memcpy (argz + *pargz_len, buf, buf_len); |
604 | |
605 | /* Assign new values. */ |
606 | *pargz = argz; |
607 | *pargz_len = argz_len; |
608 | |
609 | return 0; |
610 | } |
611 | #endif /* !HAVE_ARGZ_APPEND */ |
612 | |
613 | |
614 | #if ! HAVE_ARGZ_CREATE_SEP |
615 | # define argz_create_sep rpl_argz_create_sep |
616 | |
617 | static error_t argz_create_sep LT_PARAMS((const char *str, int delim, |
618 | char **pargz, size_t *pargz_len)); |
619 | |
620 | static error_t |
621 | argz_create_sep (str, delim, pargz, pargz_len) |
622 | const char *str; |
623 | int delim; |
624 | char **pargz; |
625 | size_t *pargz_len; |
626 | { |
627 | size_t argz_len; |
628 | char *argz = 0; |
629 | |
630 | assert (str); |
631 | assert (pargz); |
632 | assert (pargz_len); |
633 | |
634 | /* Make a copy of STR, but replacing each occurrence of |
635 | DELIM with '\0'. */ |
636 | argz_len = 1+ LT_STRLEN (str); |
637 | if (argz_len) |
638 | { |
639 | const char *p; |
640 | char *q; |
641 | |
642 | argz = LT_DLMALLOC (char, argz_len); |
643 | if (!argz) |
644 | return ENOMEM; |
645 | |
646 | for (p = str, q = argz; *p != LT_EOS_CHAR; ++p) |
647 | { |
648 | if (*p == delim) |
649 | { |
650 | /* Ignore leading delimiters, and fold consecutive |
651 | delimiters in STR into a single '\0' in ARGZ. */ |
652 | if ((q > argz) && (q[-1] != LT_EOS_CHAR)) |
653 | *q++ = LT_EOS_CHAR; |
654 | else |
655 | --argz_len; |
656 | } |
657 | else |
658 | *q++ = *p; |
659 | } |
660 | /* Copy terminating LT_EOS_CHAR. */ |
661 | *q = *p; |
662 | } |
663 | |
664 | /* If ARGZ_LEN has shrunk to nothing, release ARGZ's memory. */ |
665 | if (!argz_len) |
666 | LT_DLFREE (argz); |
667 | |
668 | /* Assign new values. */ |
669 | *pargz = argz; |
670 | *pargz_len = argz_len; |
671 | |
672 | return 0; |
673 | } |
674 | #endif /* !HAVE_ARGZ_CREATE_SEP */ |
675 | |
676 | |
677 | #if ! HAVE_ARGZ_INSERT |
678 | # define argz_insert rpl_argz_insert |
679 | |
680 | static error_t argz_insert LT_PARAMS((char **pargz, size_t *pargz_len, |
681 | char *before, const char *entry)); |
682 | |
683 | static error_t |
684 | argz_insert (pargz, pargz_len, before, entry) |
685 | char **pargz; |
686 | size_t *pargz_len; |
687 | char *before; |
688 | const char *entry; |
689 | { |
690 | assert (pargz); |
691 | assert (pargz_len); |
692 | assert (entry && *entry); |
693 | |
694 | /* No BEFORE address indicates ENTRY should be inserted after the |
695 | current last element. */ |
696 | if (!before) |
697 | return argz_append (pargz, pargz_len, entry, 1+ LT_STRLEN (entry)); |
698 | |
699 | /* This probably indicates a programmer error, but to preserve |
700 | semantics, scan back to the start of an entry if BEFORE points |
701 | into the middle of it. */ |
702 | while ((before > *pargz) && (before[-1] != LT_EOS_CHAR)) |
703 | --before; |
704 | |
705 | { |
706 | size_t entry_len = 1+ LT_STRLEN (entry); |
707 | size_t argz_len = *pargz_len + entry_len; |
708 | size_t offset = before - *pargz; |
709 | char *argz = LT_DLREALLOC (char, *pargz, argz_len); |
710 | |
711 | if (!argz) |
712 | return ENOMEM; |
713 | |
714 | /* Make BEFORE point to the equivalent offset in ARGZ that it |
715 | used to have in *PARGZ incase realloc() moved the block. */ |
716 | before = argz + offset; |
717 | |
718 | /* Move the ARGZ entries starting at BEFORE up into the new |
719 | space at the end -- making room to copy ENTRY into the |
720 | resulting gap. */ |
721 | memmove (before + entry_len, before, *pargz_len - offset); |
722 | memcpy (before, entry, entry_len); |
723 | |
724 | /* Assign new values. */ |
725 | *pargz = argz; |
726 | *pargz_len = argz_len; |
727 | } |
728 | |
729 | return 0; |
730 | } |
731 | #endif /* !HAVE_ARGZ_INSERT */ |
732 | |
733 | |
734 | #if ! HAVE_ARGZ_NEXT |
735 | # define argz_next rpl_argz_next |
736 | |
737 | static char *argz_next LT_PARAMS((char *argz, size_t argz_len, |
738 | const char *entry)); |
739 | |
740 | static char * |
741 | argz_next (argz, argz_len, entry) |
742 | char *argz; |
743 | size_t argz_len; |
744 | const char *entry; |
745 | { |
746 | assert ((argz && argz_len) || (!argz && !argz_len)); |
747 | |
748 | if (entry) |
749 | { |
750 | /* Either ARGZ/ARGZ_LEN is empty, or ENTRY points into an address |
751 | within the ARGZ vector. */ |
752 | assert ((!argz && !argz_len) |
753 | || ((argz <= entry) && (entry < (argz + argz_len)))); |
754 | |
755 | /* Move to the char immediately after the terminating |
756 | '\0' of ENTRY. */ |
757 | entry = 1+ strchr (entry, LT_EOS_CHAR); |
758 | |
759 | /* Return either the new ENTRY, or else NULL if ARGZ is |
760 | exhausted. */ |
761 | return (entry >= argz + argz_len) ? 0 : (char *) entry; |
762 | } |
763 | else |
764 | { |
765 | /* This should probably be flagged as a programmer error, |
766 | since starting an argz_next loop with the iterator set |
767 | to ARGZ is safer. To preserve semantics, handle the NULL |
768 | case by returning the start of ARGZ (if any). */ |
769 | if (argz_len > 0) |
770 | return argz; |
771 | else |
772 | return 0; |
773 | } |
774 | } |
775 | #endif /* !HAVE_ARGZ_NEXT */ |
776 | |
777 | |
778 | |
779 | #if ! HAVE_ARGZ_STRINGIFY |
780 | # define argz_stringify rpl_argz_stringify |
781 | |
782 | static void argz_stringify LT_PARAMS((char *argz, size_t argz_len, |
783 | int sep)); |
784 | |
785 | static void |
786 | argz_stringify (argz, argz_len, sep) |
787 | char *argz; |
788 | size_t argz_len; |
789 | int sep; |
790 | { |
791 | assert ((argz && argz_len) || (!argz && !argz_len)); |
792 | |
793 | if (sep) |
794 | { |
795 | --argz_len; /* don't stringify the terminating EOS */ |
796 | while (--argz_len > 0) |
797 | { |
798 | if (argz[argz_len] == LT_EOS_CHAR) |
799 | argz[argz_len] = sep; |
800 | } |
801 | } |
802 | } |
803 | #endif /* !HAVE_ARGZ_STRINGIFY */ |
804 | |
805 | |
806 | |
807 | \f |
808 | /* --- TYPE DEFINITIONS -- */ |
809 | |
810 | |
811 | /* This type is used for the array of caller data sets in each handler. */ |
812 | typedef struct { |
813 | lt_dlcaller_id key; |
814 | lt_ptr data; |
815 | } lt_caller_data; |
816 | |
817 | |
818 | |
819 | \f |
820 | /* --- OPAQUE STRUCTURES DECLARED IN LTDL.H --- */ |
821 | |
822 | |
823 | /* Extract the diagnostic strings from the error table macro in the same |
824 | order as the enumerated indices in ltdl.h. */ |
825 | |
826 | static const char *lt_dlerror_strings[] = |
827 | { |
828 | #define LT_ERROR(name, diagnostic) (diagnostic), |
829 | lt_dlerror_table |
830 | #undef LT_ERROR |
831 | |
832 | 0 |
833 | }; |
834 | |
835 | /* This structure is used for the list of registered loaders. */ |
836 | struct lt_dlloader { |
837 | struct lt_dlloader *next; |
838 | const char *loader_name; /* identifying name for each loader */ |
839 | const char *sym_prefix; /* prefix for symbols */ |
840 | lt_module_open *module_open; |
841 | lt_module_close *module_close; |
842 | lt_find_sym *find_sym; |
843 | lt_dlloader_exit *dlloader_exit; |
844 | lt_user_data dlloader_data; |
845 | }; |
846 | |
847 | struct lt_dlhandle_struct { |
848 | struct lt_dlhandle_struct *next; |
849 | lt_dlloader *loader; /* dlopening interface */ |
850 | lt_dlinfo info; |
851 | int depcount; /* number of dependencies */ |
852 | lt_dlhandle *deplibs; /* dependencies */ |
853 | lt_module module; /* system module handle */ |
854 | lt_ptr system; /* system specific data */ |
855 | lt_caller_data *caller_data; /* per caller associated data */ |
856 | int flags; /* various boolean stats */ |
857 | }; |
858 | |
859 | /* Various boolean flags can be stored in the flags field of an |
860 | lt_dlhandle_struct... */ |
861 | #define LT_DLGET_FLAG(handle, flag) (((handle)->flags & (flag)) == (flag)) |
862 | #define LT_DLSET_FLAG(handle, flag) ((handle)->flags |= (flag)) |
863 | |
864 | #define LT_DLRESIDENT_FLAG (0x01 << 0) |
865 | /* ...add more flags here... */ |
866 | |
867 | #define LT_DLIS_RESIDENT(handle) LT_DLGET_FLAG(handle, LT_DLRESIDENT_FLAG) |
868 | |
869 | |
870 | #define LT_DLSTRERROR(name) lt_dlerror_strings[LT_CONC(LT_ERROR_,name)] |
871 | |
872 | static const char objdir[] = LTDL_OBJDIR; |
873 | static const char archive_ext[] = LTDL_ARCHIVE_EXT; |
874 | #ifdef LTDL_SHLIB_EXT |
875 | static const char shlib_ext[] = LTDL_SHLIB_EXT; |
876 | #endif |
877 | #ifdef LTDL_SYSSEARCHPATH |
878 | static const char sys_search_path[] = LTDL_SYSSEARCHPATH; |
879 | #endif |
880 | |
881 | |
882 | |
883 | \f |
884 | /* --- MUTEX LOCKING --- */ |
885 | |
886 | |
887 | /* Macros to make it easier to run the lock functions only if they have |
888 | been registered. The reason for the complicated lock macro is to |
889 | ensure that the stored error message from the last error is not |
890 | accidentally erased if the current function doesn't generate an |
891 | error of its own. */ |
892 | #define LT_DLMUTEX_LOCK() LT_STMT_START { \ |
893 | if (lt_dlmutex_lock_func) (*lt_dlmutex_lock_func)(); \ |
894 | } LT_STMT_END |
895 | #define LT_DLMUTEX_UNLOCK() LT_STMT_START { \ |
896 | if (lt_dlmutex_unlock_func) (*lt_dlmutex_unlock_func)();\ |
897 | } LT_STMT_END |
898 | #define LT_DLMUTEX_SETERROR(errormsg) LT_STMT_START { \ |
899 | if (lt_dlmutex_seterror_func) \ |
900 | (*lt_dlmutex_seterror_func) (errormsg); \ |
901 | else lt_dllast_error = (errormsg); } LT_STMT_END |
902 | #define LT_DLMUTEX_GETERROR(errormsg) LT_STMT_START { \ |
903 | if (lt_dlmutex_geterror_func) \ |
904 | (errormsg) = (*lt_dlmutex_geterror_func) (); \ |
905 | else (errormsg) = lt_dllast_error; } LT_STMT_END |
906 | |
907 | /* The mutex functions stored here are global, and are necessarily the |
908 | same for all threads that wish to share access to libltdl. */ |
909 | static lt_dlmutex_lock *lt_dlmutex_lock_func = 0; |
910 | static lt_dlmutex_unlock *lt_dlmutex_unlock_func = 0; |
911 | static lt_dlmutex_seterror *lt_dlmutex_seterror_func = 0; |
912 | static lt_dlmutex_geterror *lt_dlmutex_geterror_func = 0; |
913 | static const char *lt_dllast_error = 0; |
914 | |
915 | |
916 | /* Either set or reset the mutex functions. Either all the arguments must |
917 | be valid functions, or else all can be NULL to turn off locking entirely. |
918 | The registered functions should be manipulating a static global lock |
919 | from the lock() and unlock() callbacks, which needs to be reentrant. */ |
920 | int |
921 | lt_dlmutex_register (lock, unlock, seterror, geterror) |
922 | lt_dlmutex_lock *lock; |
923 | lt_dlmutex_unlock *unlock; |
924 | lt_dlmutex_seterror *seterror; |
925 | lt_dlmutex_geterror *geterror; |
926 | { |
ac40fd9e |
927 | lt_dlmutex_unlock *old_unlock = lt_dlmutex_unlock_func; |
d9898ee8 |
928 | int errors = 0; |
929 | |
930 | /* Lock using the old lock() callback, if any. */ |
931 | LT_DLMUTEX_LOCK (); |
932 | |
933 | if ((lock && unlock && seterror && geterror) |
934 | || !(lock || unlock || seterror || geterror)) |
935 | { |
936 | lt_dlmutex_lock_func = lock; |
937 | lt_dlmutex_unlock_func = unlock; |
ac40fd9e |
938 | lt_dlmutex_seterror_func = seterror; |
d9898ee8 |
939 | lt_dlmutex_geterror_func = geterror; |
940 | } |
941 | else |
942 | { |
943 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_MUTEX_ARGS)); |
944 | ++errors; |
945 | } |
946 | |
947 | /* Use the old unlock() callback we saved earlier, if any. Otherwise |
948 | record any errors using internal storage. */ |
949 | if (old_unlock) |
950 | (*old_unlock) (); |
951 | |
952 | /* Return the number of errors encountered during the execution of |
953 | this function. */ |
954 | return errors; |
955 | } |
956 | |
957 | |
958 | |
959 | \f |
960 | /* --- ERROR HANDLING --- */ |
961 | |
962 | |
963 | static const char **user_error_strings = 0; |
964 | static int errorcount = LT_ERROR_MAX; |
965 | |
966 | int |
967 | lt_dladderror (diagnostic) |
968 | const char *diagnostic; |
969 | { |
970 | int errindex = 0; |
971 | int result = -1; |
972 | const char **temp = (const char **) 0; |
973 | |
974 | assert (diagnostic); |
975 | |
976 | LT_DLMUTEX_LOCK (); |
977 | |
978 | errindex = errorcount - LT_ERROR_MAX; |
979 | temp = LT_EREALLOC (const char *, user_error_strings, 1 + errindex); |
980 | if (temp) |
981 | { |
982 | user_error_strings = temp; |
983 | user_error_strings[errindex] = diagnostic; |
984 | result = errorcount++; |
985 | } |
986 | |
987 | LT_DLMUTEX_UNLOCK (); |
988 | |
989 | return result; |
990 | } |
991 | |
992 | int |
993 | lt_dlseterror (errindex) |
994 | int errindex; |
995 | { |
996 | int errors = 0; |
997 | |
998 | LT_DLMUTEX_LOCK (); |
999 | |
1000 | if (errindex >= errorcount || errindex < 0) |
1001 | { |
1002 | /* Ack! Error setting the error message! */ |
1003 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_ERRORCODE)); |
1004 | ++errors; |
1005 | } |
1006 | else if (errindex < LT_ERROR_MAX) |
1007 | { |
1008 | /* No error setting the error message! */ |
1009 | LT_DLMUTEX_SETERROR (lt_dlerror_strings[errindex]); |
1010 | } |
1011 | else |
1012 | { |
1013 | /* No error setting the error message! */ |
1014 | LT_DLMUTEX_SETERROR (user_error_strings[errindex - LT_ERROR_MAX]); |
1015 | } |
1016 | |
1017 | LT_DLMUTEX_UNLOCK (); |
1018 | |
1019 | return errors; |
1020 | } |
1021 | |
1022 | static lt_ptr |
1023 | lt_emalloc (size) |
1024 | size_t size; |
1025 | { |
1026 | lt_ptr mem = lt_dlmalloc (size); |
1027 | if (size && !mem) |
1028 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
1029 | return mem; |
1030 | } |
1031 | |
1032 | static lt_ptr |
1033 | lt_erealloc (addr, size) |
1034 | lt_ptr addr; |
1035 | size_t size; |
1036 | { |
1037 | lt_ptr mem = lt_dlrealloc (addr, size); |
1038 | if (size && !mem) |
1039 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
1040 | return mem; |
1041 | } |
1042 | |
1043 | static char * |
1044 | lt_estrdup (str) |
1045 | const char *str; |
1046 | { |
1047 | char *copy = strdup (str); |
1048 | if (LT_STRLEN (str) && !copy) |
1049 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
1050 | return copy; |
1051 | } |
1052 | |
1053 | |
1054 | |
1055 | \f |
1056 | /* --- DLOPEN() INTERFACE LOADER --- */ |
1057 | |
1058 | |
1059 | #if HAVE_LIBDL |
1060 | |
1061 | /* dynamic linking with dlopen/dlsym */ |
1062 | |
1063 | #if HAVE_DLFCN_H |
1064 | # include <dlfcn.h> |
1065 | #endif |
1066 | |
1067 | #if HAVE_SYS_DL_H |
1068 | # include <sys/dl.h> |
1069 | #endif |
1070 | |
1071 | #ifdef RTLD_GLOBAL |
1072 | # define LT_GLOBAL RTLD_GLOBAL |
1073 | #else |
1074 | # ifdef DL_GLOBAL |
1075 | # define LT_GLOBAL DL_GLOBAL |
1076 | # endif |
1077 | #endif /* !RTLD_GLOBAL */ |
1078 | #ifndef LT_GLOBAL |
1079 | # define LT_GLOBAL 0 |
1080 | #endif /* !LT_GLOBAL */ |
1081 | |
1082 | /* We may have to define LT_LAZY_OR_NOW in the command line if we |
1083 | find out it does not work in some platform. */ |
1084 | #ifndef LT_LAZY_OR_NOW |
1085 | # ifdef RTLD_LAZY |
1086 | # define LT_LAZY_OR_NOW RTLD_LAZY |
1087 | # else |
1088 | # ifdef DL_LAZY |
1089 | # define LT_LAZY_OR_NOW DL_LAZY |
1090 | # endif |
1091 | # endif /* !RTLD_LAZY */ |
1092 | #endif |
1093 | #ifndef LT_LAZY_OR_NOW |
1094 | # ifdef RTLD_NOW |
1095 | # define LT_LAZY_OR_NOW RTLD_NOW |
1096 | # else |
1097 | # ifdef DL_NOW |
1098 | # define LT_LAZY_OR_NOW DL_NOW |
1099 | # endif |
1100 | # endif /* !RTLD_NOW */ |
1101 | #endif |
1102 | #ifndef LT_LAZY_OR_NOW |
1103 | # define LT_LAZY_OR_NOW 0 |
1104 | #endif /* !LT_LAZY_OR_NOW */ |
1105 | |
1106 | #if HAVE_DLERROR |
1107 | # define DLERROR(arg) dlerror () |
1108 | #else |
1109 | # define DLERROR(arg) LT_DLSTRERROR (arg) |
1110 | #endif |
1111 | |
1112 | static lt_module |
1113 | sys_dl_open (loader_data, filename) |
1114 | lt_user_data loader_data; |
1115 | const char *filename; |
1116 | { |
1117 | lt_module module = dlopen (filename, LT_GLOBAL | LT_LAZY_OR_NOW); |
1118 | |
1119 | if (!module) |
1120 | { |
1121 | LT_DLMUTEX_SETERROR (DLERROR (CANNOT_OPEN)); |
1122 | } |
1123 | |
1124 | return module; |
1125 | } |
1126 | |
1127 | static int |
1128 | sys_dl_close (loader_data, module) |
1129 | lt_user_data loader_data; |
1130 | lt_module module; |
1131 | { |
1132 | int errors = 0; |
1133 | |
1134 | if (dlclose (module) != 0) |
1135 | { |
1136 | LT_DLMUTEX_SETERROR (DLERROR (CANNOT_CLOSE)); |
1137 | ++errors; |
1138 | } |
1139 | |
1140 | return errors; |
1141 | } |
1142 | |
1143 | static lt_ptr |
1144 | sys_dl_sym (loader_data, module, symbol) |
1145 | lt_user_data loader_data; |
1146 | lt_module module; |
1147 | const char *symbol; |
1148 | { |
1149 | lt_ptr address = dlsym (module, symbol); |
1150 | |
1151 | if (!address) |
1152 | { |
1153 | LT_DLMUTEX_SETERROR (DLERROR (SYMBOL_NOT_FOUND)); |
1154 | } |
1155 | |
1156 | return address; |
1157 | } |
1158 | |
1159 | static struct lt_user_dlloader sys_dl = |
1160 | { |
1161 | # ifdef NEED_USCORE |
1162 | "_", |
1163 | # else |
1164 | 0, |
1165 | # endif |
1166 | sys_dl_open, sys_dl_close, sys_dl_sym, 0, 0 }; |
1167 | |
1168 | |
1169 | #endif /* HAVE_LIBDL */ |
1170 | |
1171 | |
1172 | \f |
1173 | /* --- SHL_LOAD() INTERFACE LOADER --- */ |
1174 | |
1175 | #if HAVE_SHL_LOAD |
1176 | |
1177 | /* dynamic linking with shl_load (HP-UX) (comments from gmodule) */ |
1178 | |
1179 | #ifdef HAVE_DL_H |
1180 | # include <dl.h> |
1181 | #endif |
1182 | |
1183 | /* some flags are missing on some systems, so we provide |
1184 | * harmless defaults. |
1185 | * |
1186 | * Mandatory: |
1187 | * BIND_IMMEDIATE - Resolve symbol references when the library is loaded. |
1188 | * BIND_DEFERRED - Delay code symbol resolution until actual reference. |
1189 | * |
1190 | * Optionally: |
1191 | * BIND_FIRST - Place the library at the head of the symbol search |
1192 | * order. |
1193 | * BIND_NONFATAL - The default BIND_IMMEDIATE behavior is to treat all |
1194 | * unsatisfied symbols as fatal. This flag allows |
1195 | * binding of unsatisfied code symbols to be deferred |
1196 | * until use. |
1197 | * [Perl: For certain libraries, like DCE, deferred |
1198 | * binding often causes run time problems. Adding |
1199 | * BIND_NONFATAL to BIND_IMMEDIATE still allows |
1200 | * unresolved references in situations like this.] |
1201 | * BIND_NOSTART - Do not call the initializer for the shared library |
1202 | * when the library is loaded, nor on a future call to |
1203 | * shl_unload(). |
1204 | * BIND_VERBOSE - Print verbose messages concerning possible |
1205 | * unsatisfied symbols. |
1206 | * |
1207 | * hp9000s700/hp9000s800: |
1208 | * BIND_RESTRICTED - Restrict symbols visible by the library to those |
1209 | * present at library load time. |
1210 | * DYNAMIC_PATH - Allow the loader to dynamically search for the |
1211 | * library specified by the path argument. |
1212 | */ |
1213 | |
1214 | #ifndef DYNAMIC_PATH |
1215 | # define DYNAMIC_PATH 0 |
1216 | #endif |
1217 | #ifndef BIND_RESTRICTED |
1218 | # define BIND_RESTRICTED 0 |
1219 | #endif |
1220 | |
1221 | #define LT_BIND_FLAGS (BIND_IMMEDIATE | BIND_NONFATAL | DYNAMIC_PATH) |
1222 | |
1223 | static lt_module |
1224 | sys_shl_open (loader_data, filename) |
1225 | lt_user_data loader_data; |
1226 | const char *filename; |
1227 | { |
1228 | static shl_t self = (shl_t) 0; |
1229 | lt_module module = shl_load (filename, LT_BIND_FLAGS, 0L); |
1230 | |
1231 | /* Since searching for a symbol against a NULL module handle will also |
1232 | look in everything else that was already loaded and exported with |
1233 | the -E compiler flag, we always cache a handle saved before any |
1234 | modules are loaded. */ |
1235 | if (!self) |
1236 | { |
1237 | lt_ptr address; |
1238 | shl_findsym (&self, "main", TYPE_UNDEFINED, &address); |
1239 | } |
1240 | |
1241 | if (!filename) |
1242 | { |
1243 | module = self; |
1244 | } |
1245 | else |
1246 | { |
1247 | module = shl_load (filename, LT_BIND_FLAGS, 0L); |
1248 | |
1249 | if (!module) |
1250 | { |
1251 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN)); |
1252 | } |
1253 | } |
1254 | |
1255 | return module; |
1256 | } |
1257 | |
1258 | static int |
1259 | sys_shl_close (loader_data, module) |
1260 | lt_user_data loader_data; |
1261 | lt_module module; |
1262 | { |
1263 | int errors = 0; |
1264 | |
1265 | if (module && (shl_unload ((shl_t) (module)) != 0)) |
1266 | { |
1267 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); |
1268 | ++errors; |
1269 | } |
1270 | |
1271 | return errors; |
1272 | } |
1273 | |
1274 | static lt_ptr |
1275 | sys_shl_sym (loader_data, module, symbol) |
1276 | lt_user_data loader_data; |
1277 | lt_module module; |
1278 | const char *symbol; |
1279 | { |
1280 | lt_ptr address = 0; |
1281 | |
1282 | /* sys_shl_open should never return a NULL module handle */ |
1283 | if (module == (lt_module) 0) |
1284 | { |
1285 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); |
1286 | } |
1287 | else if (!shl_findsym((shl_t*) &module, symbol, TYPE_UNDEFINED, &address)) |
1288 | { |
1289 | if (!address) |
1290 | { |
1291 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
1292 | } |
1293 | } |
1294 | |
1295 | return address; |
1296 | } |
1297 | |
1298 | static struct lt_user_dlloader sys_shl = { |
1299 | 0, sys_shl_open, sys_shl_close, sys_shl_sym, 0, 0 |
1300 | }; |
1301 | |
1302 | #endif /* HAVE_SHL_LOAD */ |
1303 | |
1304 | |
1305 | |
1306 | \f |
1307 | /* --- LOADLIBRARY() INTERFACE LOADER --- */ |
1308 | |
1309 | #ifdef __WINDOWS__ |
1310 | |
1311 | /* dynamic linking for Win32 */ |
1312 | |
1313 | #include <windows.h> |
1314 | |
1315 | /* Forward declaration; required to implement handle search below. */ |
1316 | static lt_dlhandle handles; |
1317 | |
1318 | static lt_module |
1319 | sys_wll_open (loader_data, filename) |
1320 | lt_user_data loader_data; |
1321 | const char *filename; |
1322 | { |
1323 | lt_dlhandle cur; |
1324 | lt_module module = 0; |
1325 | const char *errormsg = 0; |
1326 | char *searchname = 0; |
1327 | char *ext; |
1328 | char self_name_buf[MAX_PATH]; |
1329 | |
1330 | if (!filename) |
1331 | { |
1332 | /* Get the name of main module */ |
1333 | *self_name_buf = 0; |
1334 | GetModuleFileName (NULL, self_name_buf, sizeof (self_name_buf)); |
1335 | filename = ext = self_name_buf; |
1336 | } |
1337 | else |
1338 | { |
1339 | ext = strrchr (filename, '.'); |
1340 | } |
1341 | |
1342 | if (ext) |
1343 | { |
1344 | /* FILENAME already has an extension. */ |
1345 | searchname = lt_estrdup (filename); |
1346 | } |
1347 | else |
1348 | { |
1349 | /* Append a `.' to stop Windows from adding an |
1350 | implicit `.dll' extension. */ |
1351 | searchname = LT_EMALLOC (char, 2+ LT_STRLEN (filename)); |
1352 | if (searchname) |
1353 | sprintf (searchname, "%s.", filename); |
1354 | } |
1355 | if (!searchname) |
1356 | return 0; |
1357 | |
1358 | { |
1359 | /* Silence dialog from LoadLibrary on some failures. |
1360 | No way to get the error mode, but to set it, |
1361 | so set it twice to preserve any previous flags. */ |
1362 | UINT errormode = SetErrorMode(SEM_FAILCRITICALERRORS); |
1363 | SetErrorMode(errormode | SEM_FAILCRITICALERRORS); |
1364 | |
1365 | #if defined(__CYGWIN__) |
1366 | { |
1367 | char wpath[MAX_PATH]; |
1368 | cygwin_conv_to_full_win32_path (searchname, wpath); |
1369 | module = LoadLibrary (wpath); |
1370 | } |
1371 | #else |
1372 | module = LoadLibrary (searchname); |
1373 | #endif |
1374 | |
1375 | /* Restore the error mode. */ |
1376 | SetErrorMode(errormode); |
1377 | } |
1378 | |
1379 | LT_DLFREE (searchname); |
1380 | |
1381 | /* libltdl expects this function to fail if it is unable |
1382 | to physically load the library. Sadly, LoadLibrary |
1383 | will search the loaded libraries for a match and return |
1384 | one of them if the path search load fails. |
1385 | |
1386 | We check whether LoadLibrary is returning a handle to |
1387 | an already loaded module, and simulate failure if we |
1388 | find one. */ |
1389 | LT_DLMUTEX_LOCK (); |
1390 | cur = handles; |
1391 | while (cur) |
1392 | { |
1393 | if (!cur->module) |
1394 | { |
1395 | cur = 0; |
1396 | break; |
1397 | } |
1398 | |
1399 | if (cur->module == module) |
1400 | { |
1401 | break; |
1402 | } |
1403 | |
1404 | cur = cur->next; |
1405 | } |
1406 | LT_DLMUTEX_UNLOCK (); |
1407 | |
1408 | if (cur || !module) |
1409 | { |
1410 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN)); |
1411 | module = 0; |
1412 | } |
1413 | |
1414 | return module; |
1415 | } |
1416 | |
1417 | static int |
1418 | sys_wll_close (loader_data, module) |
1419 | lt_user_data loader_data; |
1420 | lt_module module; |
1421 | { |
1422 | int errors = 0; |
1423 | |
1424 | if (FreeLibrary(module) == 0) |
1425 | { |
1426 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); |
1427 | ++errors; |
1428 | } |
1429 | |
1430 | return errors; |
1431 | } |
1432 | |
1433 | static lt_ptr |
1434 | sys_wll_sym (loader_data, module, symbol) |
1435 | lt_user_data loader_data; |
1436 | lt_module module; |
1437 | const char *symbol; |
1438 | { |
1439 | lt_ptr address = GetProcAddress (module, symbol); |
1440 | |
1441 | if (!address) |
1442 | { |
1443 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
1444 | } |
1445 | |
1446 | return address; |
1447 | } |
1448 | |
1449 | static struct lt_user_dlloader sys_wll = { |
1450 | 0, sys_wll_open, sys_wll_close, sys_wll_sym, 0, 0 |
1451 | }; |
1452 | |
1453 | #endif /* __WINDOWS__ */ |
1454 | |
1455 | |
1456 | |
1457 | \f |
1458 | /* --- LOAD_ADD_ON() INTERFACE LOADER --- */ |
1459 | |
1460 | |
1461 | #ifdef __BEOS__ |
1462 | |
1463 | /* dynamic linking for BeOS */ |
1464 | |
1465 | #include <kernel/image.h> |
1466 | |
1467 | static lt_module |
1468 | sys_bedl_open (loader_data, filename) |
1469 | lt_user_data loader_data; |
1470 | const char *filename; |
1471 | { |
1472 | image_id image = 0; |
1473 | |
1474 | if (filename) |
1475 | { |
1476 | image = load_add_on (filename); |
1477 | } |
1478 | else |
1479 | { |
1480 | image_info info; |
1481 | int32 cookie = 0; |
1482 | if (get_next_image_info (0, &cookie, &info) == B_OK) |
1483 | image = load_add_on (info.name); |
1484 | } |
1485 | |
1486 | if (image <= 0) |
1487 | { |
1488 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN)); |
1489 | image = 0; |
1490 | } |
1491 | |
1492 | return (lt_module) image; |
1493 | } |
1494 | |
1495 | static int |
1496 | sys_bedl_close (loader_data, module) |
1497 | lt_user_data loader_data; |
1498 | lt_module module; |
1499 | { |
1500 | int errors = 0; |
1501 | |
1502 | if (unload_add_on ((image_id) module) != B_OK) |
1503 | { |
1504 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); |
1505 | ++errors; |
1506 | } |
1507 | |
1508 | return errors; |
1509 | } |
1510 | |
1511 | static lt_ptr |
1512 | sys_bedl_sym (loader_data, module, symbol) |
1513 | lt_user_data loader_data; |
1514 | lt_module module; |
1515 | const char *symbol; |
1516 | { |
1517 | lt_ptr address = 0; |
1518 | image_id image = (image_id) module; |
1519 | |
1520 | if (get_image_symbol (image, symbol, B_SYMBOL_TYPE_ANY, address) != B_OK) |
1521 | { |
1522 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
1523 | address = 0; |
1524 | } |
1525 | |
1526 | return address; |
1527 | } |
1528 | |
1529 | static struct lt_user_dlloader sys_bedl = { |
1530 | 0, sys_bedl_open, sys_bedl_close, sys_bedl_sym, 0, 0 |
1531 | }; |
1532 | |
1533 | #endif /* __BEOS__ */ |
1534 | |
1535 | |
1536 | |
1537 | \f |
1538 | /* --- DLD_LINK() INTERFACE LOADER --- */ |
1539 | |
1540 | |
1541 | #if HAVE_DLD |
1542 | |
1543 | /* dynamic linking with dld */ |
1544 | |
1545 | #if HAVE_DLD_H |
1546 | #include <dld.h> |
1547 | #endif |
1548 | |
1549 | static lt_module |
1550 | sys_dld_open (loader_data, filename) |
1551 | lt_user_data loader_data; |
1552 | const char *filename; |
1553 | { |
1554 | lt_module module = strdup (filename); |
1555 | |
1556 | if (dld_link (filename) != 0) |
1557 | { |
1558 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN)); |
1559 | LT_DLFREE (module); |
1560 | module = 0; |
1561 | } |
1562 | |
1563 | return module; |
1564 | } |
1565 | |
1566 | static int |
1567 | sys_dld_close (loader_data, module) |
1568 | lt_user_data loader_data; |
1569 | lt_module module; |
1570 | { |
1571 | int errors = 0; |
1572 | |
1573 | if (dld_unlink_by_file ((char*)(module), 1) != 0) |
1574 | { |
1575 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); |
1576 | ++errors; |
1577 | } |
1578 | else |
1579 | { |
1580 | LT_DLFREE (module); |
1581 | } |
1582 | |
1583 | return errors; |
1584 | } |
1585 | |
1586 | static lt_ptr |
1587 | sys_dld_sym (loader_data, module, symbol) |
1588 | lt_user_data loader_data; |
1589 | lt_module module; |
1590 | const char *symbol; |
1591 | { |
1592 | lt_ptr address = dld_get_func (symbol); |
1593 | |
1594 | if (!address) |
1595 | { |
1596 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
1597 | } |
1598 | |
1599 | return address; |
1600 | } |
1601 | |
1602 | static struct lt_user_dlloader sys_dld = { |
1603 | 0, sys_dld_open, sys_dld_close, sys_dld_sym, 0, 0 |
1604 | }; |
1605 | |
1606 | #endif /* HAVE_DLD */ |
1607 | |
1608 | /* --- DYLD() MACOSX/DARWIN INTERFACE LOADER --- */ |
1609 | #if HAVE_DYLD |
1610 | |
1611 | |
1612 | #if HAVE_MACH_O_DYLD_H |
1613 | #if !defined(__APPLE_CC__) && !defined(__MWERKS__) && !defined(__private_extern__) |
1614 | /* Is this correct? Does it still function properly? */ |
1615 | #define __private_extern__ extern |
1616 | #endif |
1617 | # include <mach-o/dyld.h> |
1618 | #endif |
1619 | #include <mach-o/getsect.h> |
1620 | |
1621 | /* We have to put some stuff here that isn't in older dyld.h files */ |
1622 | #ifndef ENUM_DYLD_BOOL |
1623 | # define ENUM_DYLD_BOOL |
1624 | # undef FALSE |
1625 | # undef TRUE |
1626 | enum DYLD_BOOL { |
1627 | FALSE, |
1628 | TRUE |
1629 | }; |
1630 | #endif |
1631 | #ifndef LC_REQ_DYLD |
1632 | # define LC_REQ_DYLD 0x80000000 |
1633 | #endif |
1634 | #ifndef LC_LOAD_WEAK_DYLIB |
1635 | # define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD) |
1636 | #endif |
1637 | static const struct mach_header * (*ltdl_NSAddImage)(const char *image_name, unsigned long options) = 0; |
1638 | static NSSymbol (*ltdl_NSLookupSymbolInImage)(const struct mach_header *image,const char *symbolName, unsigned long options) = 0; |
1639 | static enum DYLD_BOOL (*ltdl_NSIsSymbolNameDefinedInImage)(const struct mach_header *image, const char *symbolName) = 0; |
1640 | static enum DYLD_BOOL (*ltdl_NSMakePrivateModulePublic)(NSModule module) = 0; |
1641 | |
1642 | #ifndef NSADDIMAGE_OPTION_NONE |
1643 | #define NSADDIMAGE_OPTION_NONE 0x0 |
1644 | #endif |
1645 | #ifndef NSADDIMAGE_OPTION_RETURN_ON_ERROR |
1646 | #define NSADDIMAGE_OPTION_RETURN_ON_ERROR 0x1 |
1647 | #endif |
1648 | #ifndef NSADDIMAGE_OPTION_WITH_SEARCHING |
1649 | #define NSADDIMAGE_OPTION_WITH_SEARCHING 0x2 |
1650 | #endif |
1651 | #ifndef NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED |
1652 | #define NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED 0x4 |
1653 | #endif |
1654 | #ifndef NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME |
1655 | #define NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME 0x8 |
1656 | #endif |
1657 | #ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_BIND |
1658 | #define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND 0x0 |
1659 | #endif |
1660 | #ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW |
1661 | #define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW 0x1 |
1662 | #endif |
1663 | #ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY |
1664 | #define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY 0x2 |
1665 | #endif |
1666 | #ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR |
1667 | #define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR 0x4 |
1668 | #endif |
1669 | |
1670 | |
1671 | static const char * |
1672 | lt_int_dyld_error(othererror) |
1673 | char* othererror; |
1674 | { |
1675 | /* return the dyld error string, or the passed in error string if none */ |
1676 | NSLinkEditErrors ler; |
1677 | int lerno; |
1678 | const char *errstr; |
1679 | const char *file; |
1680 | NSLinkEditError(&ler,&lerno,&file,&errstr); |
1681 | if (!errstr || !strlen(errstr)) errstr = othererror; |
1682 | return errstr; |
1683 | } |
1684 | |
1685 | static const struct mach_header * |
1686 | lt_int_dyld_get_mach_header_from_nsmodule(module) |
1687 | NSModule module; |
1688 | { |
1689 | /* There should probably be an apple dyld api for this */ |
1690 | int i=_dyld_image_count(); |
1691 | int j; |
1692 | const char *modname=NSNameOfModule(module); |
1693 | const struct mach_header *mh=NULL; |
1694 | if (!modname) return NULL; |
1695 | for (j = 0; j < i; j++) |
1696 | { |
1697 | if (!strcmp(_dyld_get_image_name(j),modname)) |
1698 | { |
1699 | mh=_dyld_get_image_header(j); |
1700 | break; |
1701 | } |
1702 | } |
1703 | return mh; |
1704 | } |
1705 | |
1706 | static const char* lt_int_dyld_lib_install_name(mh) |
1707 | const struct mach_header *mh; |
1708 | { |
1709 | /* NSAddImage is also used to get the loaded image, but it only works if the lib |
1710 | is installed, for uninstalled libs we need to check the install_names against |
1711 | each other. Note that this is still broken if DYLD_IMAGE_SUFFIX is set and a |
1712 | different lib was loaded as a result |
1713 | */ |
1714 | int j; |
1715 | struct load_command *lc; |
1716 | unsigned long offset = sizeof(struct mach_header); |
1717 | const char* retStr=NULL; |
1718 | for (j = 0; j < mh->ncmds; j++) |
1719 | { |
1720 | lc = (struct load_command*)(((unsigned long)mh) + offset); |
1721 | if (LC_ID_DYLIB == lc->cmd) |
1722 | { |
1723 | retStr=(char*)(((struct dylib_command*)lc)->dylib.name.offset + |
1724 | (unsigned long)lc); |
1725 | } |
1726 | offset += lc->cmdsize; |
1727 | } |
1728 | return retStr; |
1729 | } |
1730 | |
1731 | static const struct mach_header * |
1732 | lt_int_dyld_match_loaded_lib_by_install_name(const char *name) |
1733 | { |
1734 | int i=_dyld_image_count(); |
1735 | int j; |
1736 | const struct mach_header *mh=NULL; |
1737 | const char *id=NULL; |
1738 | for (j = 0; j < i; j++) |
1739 | { |
1740 | id=lt_int_dyld_lib_install_name(_dyld_get_image_header(j)); |
1741 | if ((id) && (!strcmp(id,name))) |
1742 | { |
1743 | mh=_dyld_get_image_header(j); |
1744 | break; |
1745 | } |
1746 | } |
1747 | return mh; |
1748 | } |
1749 | |
1750 | static NSSymbol |
1751 | lt_int_dyld_NSlookupSymbolInLinkedLibs(symbol,mh) |
1752 | const char *symbol; |
1753 | const struct mach_header *mh; |
1754 | { |
1755 | /* Safe to assume our mh is good */ |
1756 | int j; |
1757 | struct load_command *lc; |
1758 | unsigned long offset = sizeof(struct mach_header); |
1759 | NSSymbol retSym = 0; |
1760 | const struct mach_header *mh1; |
1761 | if ((ltdl_NSLookupSymbolInImage) && NSIsSymbolNameDefined(symbol) ) |
1762 | { |
1763 | for (j = 0; j < mh->ncmds; j++) |
1764 | { |
1765 | lc = (struct load_command*)(((unsigned long)mh) + offset); |
1766 | if ((LC_LOAD_DYLIB == lc->cmd) || (LC_LOAD_WEAK_DYLIB == lc->cmd)) |
1767 | { |
1768 | mh1=lt_int_dyld_match_loaded_lib_by_install_name((char*)(((struct dylib_command*)lc)->dylib.name.offset + |
1769 | (unsigned long)lc)); |
1770 | if (!mh1) |
1771 | { |
1772 | /* Maybe NSAddImage can find it */ |
1773 | mh1=ltdl_NSAddImage((char*)(((struct dylib_command*)lc)->dylib.name.offset + |
1774 | (unsigned long)lc), |
1775 | NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED + |
1776 | NSADDIMAGE_OPTION_WITH_SEARCHING + |
1777 | NSADDIMAGE_OPTION_RETURN_ON_ERROR ); |
1778 | } |
1779 | if (mh1) |
1780 | { |
1781 | retSym = ltdl_NSLookupSymbolInImage(mh1, |
1782 | symbol, |
1783 | NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW |
1784 | | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR |
1785 | ); |
1786 | if (retSym) break; |
1787 | } |
1788 | } |
1789 | offset += lc->cmdsize; |
1790 | } |
1791 | } |
1792 | return retSym; |
1793 | } |
1794 | |
1795 | static int |
1796 | sys_dyld_init() |
1797 | { |
1798 | int retCode = 0; |
1799 | int err = 0; |
1800 | if (!_dyld_present()) { |
1801 | retCode=1; |
1802 | } |
1803 | else { |
1804 | err = _dyld_func_lookup("__dyld_NSAddImage",(unsigned long*)<dl_NSAddImage); |
1805 | err = _dyld_func_lookup("__dyld_NSLookupSymbolInImage",(unsigned long*)<dl_NSLookupSymbolInImage); |
1806 | err = _dyld_func_lookup("__dyld_NSIsSymbolNameDefinedInImage",(unsigned long*)<dl_NSIsSymbolNameDefinedInImage); |
1807 | err = _dyld_func_lookup("__dyld_NSMakePrivateModulePublic",(unsigned long*)<dl_NSMakePrivateModulePublic); |
1808 | } |
1809 | return retCode; |
1810 | } |
1811 | |
1812 | static lt_module |
1813 | sys_dyld_open (loader_data, filename) |
1814 | lt_user_data loader_data; |
1815 | const char *filename; |
1816 | { |
1817 | lt_module module = 0; |
1818 | NSObjectFileImage ofi = 0; |
1819 | NSObjectFileImageReturnCode ofirc; |
1820 | |
1821 | if (!filename) |
1822 | return (lt_module)-1; |
1823 | ofirc = NSCreateObjectFileImageFromFile(filename, &ofi); |
1824 | switch (ofirc) |
1825 | { |
1826 | case NSObjectFileImageSuccess: |
1827 | module = NSLinkModule(ofi, filename, |
1828 | NSLINKMODULE_OPTION_RETURN_ON_ERROR |
1829 | | NSLINKMODULE_OPTION_PRIVATE |
1830 | | NSLINKMODULE_OPTION_BINDNOW); |
1831 | NSDestroyObjectFileImage(ofi); |
1832 | if (module) |
1833 | ltdl_NSMakePrivateModulePublic(module); |
1834 | break; |
1835 | case NSObjectFileImageInappropriateFile: |
1836 | if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage) |
1837 | { |
1838 | module = (lt_module)ltdl_NSAddImage(filename, NSADDIMAGE_OPTION_RETURN_ON_ERROR); |
1839 | break; |
1840 | } |
1841 | default: |
1842 | LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_OPEN))); |
1843 | return 0; |
1844 | } |
1845 | if (!module) LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_OPEN))); |
1846 | return module; |
1847 | } |
1848 | |
1849 | static int |
1850 | sys_dyld_close (loader_data, module) |
1851 | lt_user_data loader_data; |
1852 | lt_module module; |
1853 | { |
1854 | int retCode = 0; |
1855 | int flags = 0; |
1856 | if (module == (lt_module)-1) return 0; |
1857 | #ifdef __BIG_ENDIAN__ |
1858 | if (((struct mach_header *)module)->magic == MH_MAGIC) |
1859 | #else |
1860 | if (((struct mach_header *)module)->magic == MH_CIGAM) |
1861 | #endif |
1862 | { |
1863 | LT_DLMUTEX_SETERROR("Can not close a dylib"); |
1864 | retCode = 1; |
1865 | } |
1866 | else |
1867 | { |
1868 | #if 1 |
1869 | /* Currently, if a module contains c++ static destructors and it is unloaded, we |
1870 | get a segfault in atexit(), due to compiler and dynamic loader differences of |
1871 | opinion, this works around that. |
1872 | */ |
1873 | if ((const struct section *)NULL != |
1874 | getsectbynamefromheader(lt_int_dyld_get_mach_header_from_nsmodule(module), |
1875 | "__DATA","__mod_term_func")) |
1876 | { |
1877 | flags += NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED; |
1878 | } |
1879 | #endif |
1880 | #ifdef __ppc__ |
1881 | flags += NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES; |
1882 | #endif |
1883 | if (!NSUnLinkModule(module,flags)) |
1884 | { |
1885 | retCode=1; |
1886 | LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_CLOSE))); |
1887 | } |
1888 | } |
1889 | |
1890 | return retCode; |
1891 | } |
1892 | |
1893 | static lt_ptr |
1894 | sys_dyld_sym (loader_data, module, symbol) |
1895 | lt_user_data loader_data; |
1896 | lt_module module; |
1897 | const char *symbol; |
1898 | { |
1899 | lt_ptr address = 0; |
1900 | NSSymbol *nssym = 0; |
1901 | void *unused; |
1902 | const struct mach_header *mh=NULL; |
1903 | char saveError[256] = "Symbol not found"; |
1904 | if (module == (lt_module)-1) |
1905 | { |
1906 | _dyld_lookup_and_bind(symbol,(unsigned long*)&address,&unused); |
1907 | return address; |
1908 | } |
1909 | #ifdef __BIG_ENDIAN__ |
1910 | if (((struct mach_header *)module)->magic == MH_MAGIC) |
1911 | #else |
1912 | if (((struct mach_header *)module)->magic == MH_CIGAM) |
1913 | #endif |
1914 | { |
1915 | if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage) |
1916 | { |
1917 | mh=module; |
1918 | if (ltdl_NSIsSymbolNameDefinedInImage((struct mach_header*)module,symbol)) |
1919 | { |
1920 | nssym = ltdl_NSLookupSymbolInImage((struct mach_header*)module, |
1921 | symbol, |
1922 | NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW |
1923 | | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR |
1924 | ); |
1925 | } |
1926 | } |
1927 | |
1928 | } |
1929 | else { |
1930 | nssym = NSLookupSymbolInModule(module, symbol); |
1931 | } |
1932 | if (!nssym) |
1933 | { |
1934 | strncpy(saveError, lt_int_dyld_error(LT_DLSTRERROR(SYMBOL_NOT_FOUND)), 255); |
1935 | saveError[255] = 0; |
1936 | if (!mh) mh=lt_int_dyld_get_mach_header_from_nsmodule(module); |
1937 | nssym = lt_int_dyld_NSlookupSymbolInLinkedLibs(symbol,mh); |
1938 | } |
1939 | if (!nssym) |
1940 | { |
1941 | LT_DLMUTEX_SETERROR (saveError); |
1942 | return NULL; |
1943 | } |
1944 | return NSAddressOfSymbol(nssym); |
1945 | } |
1946 | |
1947 | static struct lt_user_dlloader sys_dyld = |
1948 | { "_", sys_dyld_open, sys_dyld_close, sys_dyld_sym, 0, 0 }; |
1949 | |
1950 | |
1951 | #endif /* HAVE_DYLD */ |
1952 | |
1953 | \f |
1954 | /* --- DLPREOPEN() INTERFACE LOADER --- */ |
1955 | |
1956 | |
1957 | /* emulate dynamic linking using preloaded_symbols */ |
1958 | |
1959 | typedef struct lt_dlsymlists_t |
1960 | { |
1961 | struct lt_dlsymlists_t *next; |
1962 | const lt_dlsymlist *syms; |
1963 | } lt_dlsymlists_t; |
1964 | |
1965 | static const lt_dlsymlist *default_preloaded_symbols = 0; |
1966 | static lt_dlsymlists_t *preloaded_symbols = 0; |
1967 | |
1968 | static int |
1969 | presym_init (loader_data) |
1970 | lt_user_data loader_data; |
1971 | { |
1972 | int errors = 0; |
1973 | |
1974 | LT_DLMUTEX_LOCK (); |
1975 | |
1976 | preloaded_symbols = 0; |
1977 | if (default_preloaded_symbols) |
1978 | { |
1979 | errors = lt_dlpreload (default_preloaded_symbols); |
1980 | } |
1981 | |
1982 | LT_DLMUTEX_UNLOCK (); |
1983 | |
1984 | return errors; |
1985 | } |
1986 | |
1987 | static int |
1988 | presym_free_symlists () |
1989 | { |
1990 | lt_dlsymlists_t *lists; |
1991 | |
1992 | LT_DLMUTEX_LOCK (); |
1993 | |
1994 | lists = preloaded_symbols; |
1995 | while (lists) |
1996 | { |
1997 | lt_dlsymlists_t *tmp = lists; |
1998 | |
1999 | lists = lists->next; |
2000 | LT_DLFREE (tmp); |
2001 | } |
2002 | preloaded_symbols = 0; |
2003 | |
2004 | LT_DLMUTEX_UNLOCK (); |
2005 | |
2006 | return 0; |
2007 | } |
2008 | |
2009 | static int |
2010 | presym_exit (loader_data) |
2011 | lt_user_data loader_data; |
2012 | { |
2013 | presym_free_symlists (); |
2014 | return 0; |
2015 | } |
2016 | |
2017 | static int |
2018 | presym_add_symlist (preloaded) |
2019 | const lt_dlsymlist *preloaded; |
2020 | { |
2021 | lt_dlsymlists_t *tmp; |
2022 | lt_dlsymlists_t *lists; |
2023 | int errors = 0; |
2024 | |
2025 | LT_DLMUTEX_LOCK (); |
2026 | |
2027 | lists = preloaded_symbols; |
2028 | while (lists) |
2029 | { |
2030 | if (lists->syms == preloaded) |
2031 | { |
2032 | goto done; |
2033 | } |
2034 | lists = lists->next; |
2035 | } |
2036 | |
2037 | tmp = LT_EMALLOC (lt_dlsymlists_t, 1); |
2038 | if (tmp) |
2039 | { |
2040 | memset (tmp, 0, sizeof(lt_dlsymlists_t)); |
2041 | tmp->syms = preloaded; |
2042 | tmp->next = preloaded_symbols; |
2043 | preloaded_symbols = tmp; |
2044 | } |
2045 | else |
2046 | { |
2047 | ++errors; |
2048 | } |
2049 | |
2050 | done: |
2051 | LT_DLMUTEX_UNLOCK (); |
2052 | return errors; |
2053 | } |
2054 | |
2055 | static lt_module |
2056 | presym_open (loader_data, filename) |
2057 | lt_user_data loader_data; |
2058 | const char *filename; |
2059 | { |
2060 | lt_dlsymlists_t *lists; |
2061 | lt_module module = (lt_module) 0; |
2062 | |
2063 | LT_DLMUTEX_LOCK (); |
2064 | lists = preloaded_symbols; |
2065 | |
2066 | if (!lists) |
2067 | { |
2068 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_SYMBOLS)); |
2069 | goto done; |
2070 | } |
2071 | |
2072 | /* Can't use NULL as the reflective symbol header, as NULL is |
2073 | used to mark the end of the entire symbol list. Self-dlpreopened |
2074 | symbols follow this magic number, chosen to be an unlikely |
2075 | clash with a real module name. */ |
2076 | if (!filename) |
2077 | { |
2078 | filename = "@PROGRAM@"; |
2079 | } |
2080 | |
2081 | while (lists) |
2082 | { |
2083 | const lt_dlsymlist *syms = lists->syms; |
2084 | |
2085 | while (syms->name) |
2086 | { |
2087 | if (!syms->address && strcmp(syms->name, filename) == 0) |
2088 | { |
2089 | module = (lt_module) syms; |
2090 | goto done; |
2091 | } |
2092 | ++syms; |
2093 | } |
2094 | |
2095 | lists = lists->next; |
2096 | } |
2097 | |
2098 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
2099 | |
2100 | done: |
2101 | LT_DLMUTEX_UNLOCK (); |
2102 | return module; |
2103 | } |
2104 | |
2105 | static int |
2106 | presym_close (loader_data, module) |
2107 | lt_user_data loader_data; |
2108 | lt_module module; |
2109 | { |
2110 | /* Just to silence gcc -Wall */ |
2111 | module = 0; |
2112 | return 0; |
2113 | } |
2114 | |
2115 | static lt_ptr |
2116 | presym_sym (loader_data, module, symbol) |
2117 | lt_user_data loader_data; |
2118 | lt_module module; |
2119 | const char *symbol; |
2120 | { |
2121 | lt_dlsymlist *syms = (lt_dlsymlist*) module; |
2122 | |
2123 | ++syms; |
2124 | while (syms->address) |
2125 | { |
2126 | if (strcmp(syms->name, symbol) == 0) |
2127 | { |
2128 | return syms->address; |
2129 | } |
2130 | |
2131 | ++syms; |
2132 | } |
2133 | |
2134 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
2135 | |
2136 | return 0; |
2137 | } |
2138 | |
2139 | static struct lt_user_dlloader presym = { |
2140 | 0, presym_open, presym_close, presym_sym, presym_exit, 0 |
2141 | }; |
2142 | |
2143 | |
2144 | |
2145 | |
2146 | \f |
2147 | /* --- DYNAMIC MODULE LOADING --- */ |
2148 | |
2149 | |
2150 | /* The type of a function used at each iteration of foreach_dirinpath(). */ |
2151 | typedef int foreach_callback_func LT_PARAMS((char *filename, lt_ptr data1, |
2152 | lt_ptr data2)); |
2153 | |
2154 | static int foreach_dirinpath LT_PARAMS((const char *search_path, |
2155 | const char *base_name, |
2156 | foreach_callback_func *func, |
2157 | lt_ptr data1, lt_ptr data2)); |
2158 | |
2159 | static int find_file_callback LT_PARAMS((char *filename, lt_ptr data, |
2160 | lt_ptr ignored)); |
2161 | static int find_handle_callback LT_PARAMS((char *filename, lt_ptr data, |
2162 | lt_ptr ignored)); |
2163 | static int foreachfile_callback LT_PARAMS((char *filename, lt_ptr data1, |
2164 | lt_ptr data2)); |
2165 | |
2166 | |
2167 | static int canonicalize_path LT_PARAMS((const char *path, |
2168 | char **pcanonical)); |
2169 | static int argzize_path LT_PARAMS((const char *path, |
2170 | char **pargz, |
2171 | size_t *pargz_len)); |
2172 | static FILE *find_file LT_PARAMS((const char *search_path, |
2173 | const char *base_name, |
2174 | char **pdir)); |
2175 | static lt_dlhandle *find_handle LT_PARAMS((const char *search_path, |
2176 | const char *base_name, |
2177 | lt_dlhandle *handle)); |
2178 | static int find_module LT_PARAMS((lt_dlhandle *handle, |
2179 | const char *dir, |
2180 | const char *libdir, |
2181 | const char *dlname, |
2182 | const char *old_name, |
2183 | int installed)); |
2184 | static int free_vars LT_PARAMS((char *dlname, char *oldname, |
2185 | char *libdir, char *deplibs)); |
2186 | static int load_deplibs LT_PARAMS((lt_dlhandle handle, |
2187 | char *deplibs)); |
2188 | static int trim LT_PARAMS((char **dest, |
2189 | const char *str)); |
2190 | static int try_dlopen LT_PARAMS((lt_dlhandle *handle, |
2191 | const char *filename)); |
2192 | static int tryall_dlopen LT_PARAMS((lt_dlhandle *handle, |
2193 | const char *filename)); |
2194 | static int unload_deplibs LT_PARAMS((lt_dlhandle handle)); |
2195 | static int lt_argz_insert LT_PARAMS((char **pargz, |
2196 | size_t *pargz_len, |
2197 | char *before, |
2198 | const char *entry)); |
2199 | static int lt_argz_insertinorder LT_PARAMS((char **pargz, |
2200 | size_t *pargz_len, |
2201 | const char *entry)); |
2202 | static int lt_argz_insertdir LT_PARAMS((char **pargz, |
2203 | size_t *pargz_len, |
2204 | const char *dirnam, |
2205 | struct dirent *dp)); |
2206 | static int lt_dlpath_insertdir LT_PARAMS((char **ppath, |
2207 | char *before, |
2208 | const char *dir)); |
2209 | static int list_files_by_dir LT_PARAMS((const char *dirnam, |
2210 | char **pargz, |
2211 | size_t *pargz_len)); |
2212 | static int file_not_found LT_PARAMS((void)); |
2213 | |
2214 | static char *user_search_path= 0; |
2215 | static lt_dlloader *loaders = 0; |
2216 | static lt_dlhandle handles = 0; |
2217 | static int initialized = 0; |
2218 | |
2219 | /* Initialize libltdl. */ |
2220 | int |
2221 | lt_dlinit () |
2222 | { |
2223 | int errors = 0; |
2224 | |
2225 | LT_DLMUTEX_LOCK (); |
2226 | |
2227 | /* Initialize only at first call. */ |
2228 | if (++initialized == 1) |
2229 | { |
2230 | handles = 0; |
2231 | user_search_path = 0; /* empty search path */ |
2232 | |
2233 | #if HAVE_LIBDL |
2234 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dl, "dlopen"); |
2235 | #endif |
2236 | #if HAVE_SHL_LOAD |
2237 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_shl, "dlopen"); |
2238 | #endif |
2239 | #ifdef __WINDOWS__ |
2240 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_wll, "dlopen"); |
2241 | #endif |
2242 | #ifdef __BEOS__ |
2243 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_bedl, "dlopen"); |
2244 | #endif |
2245 | #if HAVE_DLD |
2246 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dld, "dld"); |
2247 | #endif |
2248 | #if HAVE_DYLD |
2249 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dyld, "dyld"); |
2250 | errors += sys_dyld_init(); |
2251 | #endif |
2252 | errors += lt_dlloader_add (lt_dlloader_next (0), &presym, "dlpreload"); |
2253 | |
2254 | if (presym_init (presym.dlloader_data)) |
2255 | { |
2256 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INIT_LOADER)); |
2257 | ++errors; |
2258 | } |
2259 | else if (errors != 0) |
2260 | { |
2261 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (DLOPEN_NOT_SUPPORTED)); |
2262 | ++errors; |
2263 | } |
2264 | } |
2265 | |
2266 | LT_DLMUTEX_UNLOCK (); |
2267 | |
2268 | return errors; |
2269 | } |
2270 | |
2271 | int |
2272 | lt_dlpreload (preloaded) |
2273 | const lt_dlsymlist *preloaded; |
2274 | { |
2275 | int errors = 0; |
2276 | |
2277 | if (preloaded) |
2278 | { |
2279 | errors = presym_add_symlist (preloaded); |
2280 | } |
2281 | else |
2282 | { |
2283 | presym_free_symlists(); |
2284 | |
2285 | LT_DLMUTEX_LOCK (); |
2286 | if (default_preloaded_symbols) |
2287 | { |
2288 | errors = lt_dlpreload (default_preloaded_symbols); |
2289 | } |
2290 | LT_DLMUTEX_UNLOCK (); |
2291 | } |
2292 | |
2293 | return errors; |
2294 | } |
2295 | |
2296 | int |
2297 | lt_dlpreload_default (preloaded) |
2298 | const lt_dlsymlist *preloaded; |
2299 | { |
2300 | LT_DLMUTEX_LOCK (); |
2301 | default_preloaded_symbols = preloaded; |
2302 | LT_DLMUTEX_UNLOCK (); |
2303 | return 0; |
2304 | } |
2305 | |
2306 | int |
2307 | lt_dlexit () |
2308 | { |
2309 | /* shut down libltdl */ |
2310 | lt_dlloader *loader; |
2311 | int errors = 0; |
2312 | |
2313 | LT_DLMUTEX_LOCK (); |
2314 | loader = loaders; |
2315 | |
2316 | if (!initialized) |
2317 | { |
2318 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SHUTDOWN)); |
2319 | ++errors; |
2320 | goto done; |
2321 | } |
2322 | |
2323 | /* shut down only at last call. */ |
2324 | if (--initialized == 0) |
2325 | { |
2326 | int level; |
2327 | |
2328 | while (handles && LT_DLIS_RESIDENT (handles)) |
2329 | { |
2330 | handles = handles->next; |
2331 | } |
2332 | |
2333 | /* close all modules */ |
2334 | for (level = 1; handles; ++level) |
2335 | { |
2336 | lt_dlhandle cur = handles; |
2337 | int saw_nonresident = 0; |
2338 | |
2339 | while (cur) |
2340 | { |
2341 | lt_dlhandle tmp = cur; |
2342 | cur = cur->next; |
2343 | if (!LT_DLIS_RESIDENT (tmp)) |
2344 | saw_nonresident = 1; |
2345 | if (!LT_DLIS_RESIDENT (tmp) && tmp->info.ref_count <= level) |
2346 | { |
2347 | if (lt_dlclose (tmp)) |
2348 | { |
2349 | ++errors; |
2350 | } |
ac40fd9e |
2351 | /* Make sure that the handle pointed to by 'cur' still exists. |
2352 | lt_dlclose recursively closes dependent libraries which removes |
2353 | them from the linked list. One of these might be the one |
2354 | pointed to by 'cur'. */ |
2355 | if (cur) |
2356 | { |
2357 | for (tmp = handles; tmp; tmp = tmp->next) |
2358 | if (tmp == cur) |
2359 | break; |
2360 | if (! tmp) |
2361 | cur = handles; |
2362 | } |
d9898ee8 |
2363 | } |
2364 | } |
2365 | /* done if only resident modules are left */ |
2366 | if (!saw_nonresident) |
2367 | break; |
2368 | } |
2369 | |
2370 | /* close all loaders */ |
2371 | while (loader) |
2372 | { |
2373 | lt_dlloader *next = loader->next; |
2374 | lt_user_data data = loader->dlloader_data; |
2375 | if (loader->dlloader_exit && loader->dlloader_exit (data)) |
2376 | { |
2377 | ++errors; |
2378 | } |
2379 | |
2380 | LT_DLMEM_REASSIGN (loader, next); |
2381 | } |
2382 | loaders = 0; |
2383 | } |
2384 | |
2385 | done: |
2386 | LT_DLMUTEX_UNLOCK (); |
2387 | return errors; |
2388 | } |
2389 | |
2390 | static int |
2391 | tryall_dlopen (handle, filename) |
2392 | lt_dlhandle *handle; |
2393 | const char *filename; |
2394 | { |
2395 | lt_dlhandle cur; |
2396 | lt_dlloader *loader; |
2397 | const char *saved_error; |
2398 | int errors = 0; |
2399 | |
2400 | LT_DLMUTEX_GETERROR (saved_error); |
2401 | LT_DLMUTEX_LOCK (); |
2402 | |
2403 | cur = handles; |
2404 | loader = loaders; |
2405 | |
2406 | /* check whether the module was already opened */ |
2407 | while (cur) |
2408 | { |
2409 | /* try to dlopen the program itself? */ |
2410 | if (!cur->info.filename && !filename) |
2411 | { |
2412 | break; |
2413 | } |
2414 | |
2415 | if (cur->info.filename && filename |
2416 | && strcmp (cur->info.filename, filename) == 0) |
2417 | { |
2418 | break; |
2419 | } |
2420 | |
2421 | cur = cur->next; |
2422 | } |
2423 | |
2424 | if (cur) |
2425 | { |
2426 | ++cur->info.ref_count; |
2427 | *handle = cur; |
2428 | goto done; |
2429 | } |
2430 | |
2431 | cur = *handle; |
2432 | if (filename) |
2433 | { |
2434 | /* Comment out the check of file permissions using access. |
2435 | This call seems to always return -1 with error EACCES. |
2436 | */ |
2437 | /* We need to catch missing file errors early so that |
2438 | file_not_found() can detect what happened. |
2439 | if (access (filename, R_OK) != 0) |
2440 | { |
2441 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
2442 | ++errors; |
2443 | goto done; |
2444 | } */ |
2445 | |
2446 | cur->info.filename = lt_estrdup (filename); |
2447 | if (!cur->info.filename) |
2448 | { |
2449 | ++errors; |
2450 | goto done; |
2451 | } |
2452 | } |
2453 | else |
2454 | { |
2455 | cur->info.filename = 0; |
2456 | } |
2457 | |
2458 | while (loader) |
2459 | { |
2460 | lt_user_data data = loader->dlloader_data; |
2461 | |
2462 | cur->module = loader->module_open (data, filename); |
2463 | |
2464 | if (cur->module != 0) |
2465 | { |
2466 | break; |
2467 | } |
2468 | loader = loader->next; |
2469 | } |
2470 | |
2471 | if (!loader) |
2472 | { |
2473 | LT_DLFREE (cur->info.filename); |
2474 | ++errors; |
2475 | goto done; |
2476 | } |
2477 | |
2478 | cur->loader = loader; |
2479 | LT_DLMUTEX_SETERROR (saved_error); |
2480 | |
2481 | done: |
2482 | LT_DLMUTEX_UNLOCK (); |
2483 | |
2484 | return errors; |
2485 | } |
2486 | |
2487 | static int |
2488 | tryall_dlopen_module (handle, prefix, dirname, dlname) |
2489 | lt_dlhandle *handle; |
2490 | const char *prefix; |
2491 | const char *dirname; |
2492 | const char *dlname; |
2493 | { |
2494 | int error = 0; |
2495 | char *filename = 0; |
2496 | size_t filename_len = 0; |
2497 | size_t dirname_len = LT_STRLEN (dirname); |
2498 | |
2499 | assert (handle); |
2500 | assert (dirname); |
2501 | assert (dlname); |
2502 | #ifdef LT_DIRSEP_CHAR |
2503 | /* Only canonicalized names (i.e. with DIRSEP chars already converted) |
2504 | should make it into this function: */ |
2505 | assert (strchr (dirname, LT_DIRSEP_CHAR) == 0); |
2506 | #endif |
2507 | |
2508 | if (dirname_len > 0) |
2509 | if (dirname[dirname_len -1] == '/') |
2510 | --dirname_len; |
2511 | filename_len = dirname_len + 1 + LT_STRLEN (dlname); |
2512 | |
2513 | /* Allocate memory, and combine DIRNAME and MODULENAME into it. |
2514 | The PREFIX (if any) is handled below. */ |
2515 | filename = LT_EMALLOC (char, dirname_len + 1 + filename_len + 1); |
2516 | if (!filename) |
2517 | return 1; |
2518 | |
2519 | sprintf (filename, "%.*s/%s", (int) dirname_len, dirname, dlname); |
2520 | |
2521 | /* Now that we have combined DIRNAME and MODULENAME, if there is |
2522 | also a PREFIX to contend with, simply recurse with the arguments |
2523 | shuffled. Otherwise, attempt to open FILENAME as a module. */ |
2524 | if (prefix) |
2525 | { |
2526 | error += tryall_dlopen_module (handle, |
2527 | (const char *) 0, prefix, filename); |
2528 | } |
2529 | else if (tryall_dlopen (handle, filename) != 0) |
2530 | { |
2531 | ++error; |
2532 | } |
2533 | |
2534 | LT_DLFREE (filename); |
2535 | return error; |
2536 | } |
2537 | |
2538 | static int |
2539 | find_module (handle, dir, libdir, dlname, old_name, installed) |
2540 | lt_dlhandle *handle; |
2541 | const char *dir; |
2542 | const char *libdir; |
2543 | const char *dlname; |
2544 | const char *old_name; |
2545 | int installed; |
2546 | { |
2547 | /* Try to open the old library first; if it was dlpreopened, |
2548 | we want the preopened version of it, even if a dlopenable |
2549 | module is available. */ |
2550 | if (old_name && tryall_dlopen (handle, old_name) == 0) |
2551 | { |
2552 | return 0; |
2553 | } |
2554 | |
2555 | /* Try to open the dynamic library. */ |
2556 | if (dlname) |
2557 | { |
2558 | /* try to open the installed module */ |
2559 | if (installed && libdir) |
2560 | { |
2561 | if (tryall_dlopen_module (handle, |
2562 | (const char *) 0, libdir, dlname) == 0) |
2563 | return 0; |
2564 | } |
2565 | |
2566 | /* try to open the not-installed module */ |
2567 | if (!installed) |
2568 | { |
2569 | if (tryall_dlopen_module (handle, dir, objdir, dlname) == 0) |
2570 | return 0; |
2571 | } |
2572 | |
2573 | /* maybe it was moved to another directory */ |
2574 | { |
2575 | if (dir && (tryall_dlopen_module (handle, |
2576 | (const char *) 0, dir, dlname) == 0)) |
2577 | return 0; |
2578 | } |
2579 | } |
2580 | |
2581 | return 1; |
2582 | } |
2583 | |
2584 | |
2585 | static int |
2586 | canonicalize_path (path, pcanonical) |
2587 | const char *path; |
2588 | char **pcanonical; |
2589 | { |
2590 | char *canonical = 0; |
2591 | |
2592 | assert (path && *path); |
2593 | assert (pcanonical); |
2594 | |
2595 | canonical = LT_EMALLOC (char, 1+ LT_STRLEN (path)); |
2596 | if (!canonical) |
2597 | return 1; |
2598 | |
2599 | { |
2600 | size_t dest = 0; |
2601 | size_t src; |
2602 | for (src = 0; path[src] != LT_EOS_CHAR; ++src) |
2603 | { |
2604 | /* Path separators are not copied to the beginning or end of |
2605 | the destination, or if another separator would follow |
2606 | immediately. */ |
2607 | if (path[src] == LT_PATHSEP_CHAR) |
2608 | { |
2609 | if ((dest == 0) |
2610 | || (path[1+ src] == LT_PATHSEP_CHAR) |
2611 | || (path[1+ src] == LT_EOS_CHAR)) |
2612 | continue; |
2613 | } |
2614 | |
2615 | /* Anything other than a directory separator is copied verbatim. */ |
2616 | if ((path[src] != '/') |
2617 | #ifdef LT_DIRSEP_CHAR |
2618 | && (path[src] != LT_DIRSEP_CHAR) |
2619 | #endif |
2620 | ) |
2621 | { |
2622 | canonical[dest++] = path[src]; |
2623 | } |
2624 | /* Directory separators are converted and copied only if they are |
2625 | not at the end of a path -- i.e. before a path separator or |
2626 | NULL terminator. */ |
2627 | else if ((path[1+ src] != LT_PATHSEP_CHAR) |
2628 | && (path[1+ src] != LT_EOS_CHAR) |
2629 | #ifdef LT_DIRSEP_CHAR |
2630 | && (path[1+ src] != LT_DIRSEP_CHAR) |
2631 | #endif |
2632 | && (path[1+ src] != '/')) |
2633 | { |
2634 | canonical[dest++] = '/'; |
2635 | } |
2636 | } |
2637 | |
2638 | /* Add an end-of-string marker at the end. */ |
2639 | canonical[dest] = LT_EOS_CHAR; |
2640 | } |
2641 | |
2642 | /* Assign new value. */ |
2643 | *pcanonical = canonical; |
2644 | |
2645 | return 0; |
2646 | } |
2647 | |
2648 | static int |
2649 | argzize_path (path, pargz, pargz_len) |
2650 | const char *path; |
2651 | char **pargz; |
2652 | size_t *pargz_len; |
2653 | { |
2654 | error_t error; |
2655 | |
2656 | assert (path); |
2657 | assert (pargz); |
2658 | assert (pargz_len); |
2659 | |
2660 | if ((error = argz_create_sep (path, LT_PATHSEP_CHAR, pargz, pargz_len))) |
2661 | { |
2662 | switch (error) |
2663 | { |
2664 | case ENOMEM: |
2665 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
2666 | break; |
2667 | default: |
2668 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); |
2669 | break; |
2670 | } |
2671 | |
2672 | return 1; |
2673 | } |
2674 | |
2675 | return 0; |
2676 | } |
2677 | |
2678 | /* Repeatedly call FUNC with each LT_PATHSEP_CHAR delimited element |
2679 | of SEARCH_PATH and references to DATA1 and DATA2, until FUNC returns |
2680 | non-zero or all elements are exhausted. If BASE_NAME is non-NULL, |
2681 | it is appended to each SEARCH_PATH element before FUNC is called. */ |
2682 | static int |
2683 | foreach_dirinpath (search_path, base_name, func, data1, data2) |
2684 | const char *search_path; |
2685 | const char *base_name; |
2686 | foreach_callback_func *func; |
2687 | lt_ptr data1; |
2688 | lt_ptr data2; |
2689 | { |
2690 | int result = 0; |
2691 | int filenamesize = 0; |
2692 | size_t lenbase = LT_STRLEN (base_name); |
2693 | size_t argz_len = 0; |
2694 | char *argz = 0; |
2695 | char *filename = 0; |
2696 | char *canonical = 0; |
2697 | |
2698 | LT_DLMUTEX_LOCK (); |
2699 | |
2700 | if (!search_path || !*search_path) |
2701 | { |
2702 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
2703 | goto cleanup; |
2704 | } |
2705 | |
2706 | if (canonicalize_path (search_path, &canonical) != 0) |
2707 | goto cleanup; |
2708 | |
2709 | if (argzize_path (canonical, &argz, &argz_len) != 0) |
2710 | goto cleanup; |
2711 | |
2712 | { |
2713 | char *dir_name = 0; |
2714 | while ((dir_name = argz_next (argz, argz_len, dir_name))) |
2715 | { |
2716 | size_t lendir = LT_STRLEN (dir_name); |
2717 | |
2718 | if (lendir +1 +lenbase >= filenamesize) |
2719 | { |
2720 | LT_DLFREE (filename); |
2721 | filenamesize = lendir +1 +lenbase +1; /* "/d" + '/' + "f" + '\0' */ |
2722 | filename = LT_EMALLOC (char, filenamesize); |
2723 | if (!filename) |
2724 | goto cleanup; |
2725 | } |
2726 | |
2727 | assert (filenamesize > lendir); |
2728 | strcpy (filename, dir_name); |
2729 | |
2730 | if (base_name && *base_name) |
2731 | { |
2732 | if (filename[lendir -1] != '/') |
2733 | filename[lendir++] = '/'; |
2734 | strcpy (filename +lendir, base_name); |
2735 | } |
2736 | |
2737 | if ((result = (*func) (filename, data1, data2))) |
2738 | { |
2739 | break; |
2740 | } |
2741 | } |
2742 | } |
2743 | |
2744 | cleanup: |
2745 | LT_DLFREE (argz); |
2746 | LT_DLFREE (canonical); |
2747 | LT_DLFREE (filename); |
2748 | |
2749 | LT_DLMUTEX_UNLOCK (); |
2750 | |
2751 | return result; |
2752 | } |
2753 | |
2754 | /* If FILEPATH can be opened, store the name of the directory component |
2755 | in DATA1, and the opened FILE* structure address in DATA2. Otherwise |
2756 | DATA1 is unchanged, but DATA2 is set to a pointer to NULL. */ |
2757 | static int |
2758 | find_file_callback (filename, data1, data2) |
2759 | char *filename; |
2760 | lt_ptr data1; |
2761 | lt_ptr data2; |
2762 | { |
2763 | char **pdir = (char **) data1; |
2764 | FILE **pfile = (FILE **) data2; |
2765 | int is_done = 0; |
2766 | |
2767 | assert (filename && *filename); |
2768 | assert (pdir); |
2769 | assert (pfile); |
2770 | |
2771 | if ((*pfile = fopen (filename, LT_READTEXT_MODE))) |
2772 | { |
2773 | char *dirend = strrchr (filename, '/'); |
2774 | |
2775 | if (dirend > filename) |
2776 | *dirend = LT_EOS_CHAR; |
2777 | |
2778 | LT_DLFREE (*pdir); |
2779 | *pdir = lt_estrdup (filename); |
2780 | is_done = (*pdir == 0) ? -1 : 1; |
2781 | } |
2782 | |
2783 | return is_done; |
2784 | } |
2785 | |
2786 | static FILE * |
2787 | find_file (search_path, base_name, pdir) |
2788 | const char *search_path; |
2789 | const char *base_name; |
2790 | char **pdir; |
2791 | { |
2792 | FILE *file = 0; |
2793 | |
2794 | foreach_dirinpath (search_path, base_name, find_file_callback, pdir, &file); |
2795 | |
2796 | return file; |
2797 | } |
2798 | |
2799 | static int |
2800 | find_handle_callback (filename, data, ignored) |
2801 | char *filename; |
2802 | lt_ptr data; |
2803 | lt_ptr ignored; |
2804 | { |
2805 | lt_dlhandle *handle = (lt_dlhandle *) data; |
2806 | int notfound = access (filename, R_OK); |
2807 | |
2808 | /* Bail out if file cannot be read... */ |
2809 | if (notfound) |
2810 | return 0; |
2811 | |
2812 | /* Try to dlopen the file, but do not continue searching in any |
2813 | case. */ |
2814 | if (tryall_dlopen (handle, filename) != 0) |
2815 | *handle = 0; |
2816 | |
2817 | return 1; |
2818 | } |
2819 | |
2820 | /* If HANDLE was found return it, otherwise return 0. If HANDLE was |
2821 | found but could not be opened, *HANDLE will be set to 0. */ |
2822 | static lt_dlhandle * |
2823 | find_handle (search_path, base_name, handle) |
2824 | const char *search_path; |
2825 | const char *base_name; |
2826 | lt_dlhandle *handle; |
2827 | { |
2828 | if (!search_path) |
2829 | return 0; |
2830 | |
2831 | if (!foreach_dirinpath (search_path, base_name, find_handle_callback, |
2832 | handle, 0)) |
2833 | return 0; |
2834 | |
2835 | return handle; |
2836 | } |
2837 | |
2838 | static int |
2839 | load_deplibs (handle, deplibs) |
2840 | lt_dlhandle handle; |
2841 | char *deplibs; |
2842 | { |
2843 | #if LTDL_DLOPEN_DEPLIBS |
2844 | char *p, *save_search_path = 0; |
2845 | int depcount = 0; |
2846 | int i; |
2847 | char **names = 0; |
2848 | #endif |
2849 | int errors = 0; |
2850 | |
2851 | handle->depcount = 0; |
2852 | |
2853 | #if LTDL_DLOPEN_DEPLIBS |
2854 | if (!deplibs) |
2855 | { |
2856 | return errors; |
2857 | } |
2858 | ++errors; |
2859 | |
2860 | LT_DLMUTEX_LOCK (); |
2861 | if (user_search_path) |
2862 | { |
2863 | save_search_path = lt_estrdup (user_search_path); |
2864 | if (!save_search_path) |
2865 | goto cleanup; |
2866 | } |
2867 | |
2868 | /* extract search paths and count deplibs */ |
2869 | p = deplibs; |
2870 | while (*p) |
2871 | { |
2872 | if (!isspace ((int) *p)) |
2873 | { |
2874 | char *end = p+1; |
2875 | while (*end && !isspace((int) *end)) |
2876 | { |
2877 | ++end; |
2878 | } |
2879 | |
2880 | if (strncmp(p, "-L", 2) == 0 || strncmp(p, "-R", 2) == 0) |
2881 | { |
2882 | char save = *end; |
2883 | *end = 0; /* set a temporary string terminator */ |
2884 | if (lt_dladdsearchdir(p+2)) |
2885 | { |
2886 | goto cleanup; |
2887 | } |
2888 | *end = save; |
2889 | } |
2890 | else |
2891 | { |
2892 | ++depcount; |
2893 | } |
2894 | |
2895 | p = end; |
2896 | } |
2897 | else |
2898 | { |
2899 | ++p; |
2900 | } |
2901 | } |
2902 | |
2903 | if (!depcount) |
2904 | { |
2905 | errors = 0; |
2906 | goto cleanup; |
2907 | } |
2908 | |
2909 | names = LT_EMALLOC (char *, depcount * sizeof (char*)); |
2910 | if (!names) |
2911 | goto cleanup; |
2912 | |
2913 | /* now only extract the actual deplibs */ |
2914 | depcount = 0; |
2915 | p = deplibs; |
2916 | while (*p) |
2917 | { |
2918 | if (isspace ((int) *p)) |
2919 | { |
2920 | ++p; |
2921 | } |
2922 | else |
2923 | { |
2924 | char *end = p+1; |
2925 | while (*end && !isspace ((int) *end)) |
2926 | { |
2927 | ++end; |
2928 | } |
2929 | |
2930 | if (strncmp(p, "-L", 2) != 0 && strncmp(p, "-R", 2) != 0) |
2931 | { |
2932 | char *name; |
2933 | char save = *end; |
2934 | *end = 0; /* set a temporary string terminator */ |
2935 | if (strncmp(p, "-l", 2) == 0) |
2936 | { |
2937 | size_t name_len = 3+ /* "lib" */ LT_STRLEN (p + 2); |
2938 | name = LT_EMALLOC (char, 1+ name_len); |
2939 | if (name) |
2940 | sprintf (name, "lib%s", p+2); |
2941 | } |
2942 | else |
2943 | name = lt_estrdup(p); |
2944 | |
2945 | if (!name) |
2946 | goto cleanup_names; |
2947 | |
2948 | names[depcount++] = name; |
2949 | *end = save; |
2950 | } |
2951 | p = end; |
2952 | } |
2953 | } |
2954 | |
2955 | /* load the deplibs (in reverse order) |
2956 | At this stage, don't worry if the deplibs do not load correctly, |
2957 | they may already be statically linked into the loading application |
2958 | for instance. There will be a more enlightening error message |
2959 | later on if the loaded module cannot resolve all of its symbols. */ |
2960 | if (depcount) |
2961 | { |
2962 | int j = 0; |
2963 | |
2964 | handle->deplibs = (lt_dlhandle*) LT_EMALLOC (lt_dlhandle *, depcount); |
2965 | if (!handle->deplibs) |
ac40fd9e |
2966 | goto cleanup_names; |
d9898ee8 |
2967 | |
2968 | for (i = 0; i < depcount; ++i) |
2969 | { |
2970 | handle->deplibs[j] = lt_dlopenext(names[depcount-1-i]); |
2971 | if (handle->deplibs[j]) |
2972 | { |
2973 | ++j; |
2974 | } |
2975 | } |
2976 | |
2977 | handle->depcount = j; /* Number of successfully loaded deplibs */ |
2978 | errors = 0; |
2979 | } |
2980 | |
2981 | cleanup_names: |
2982 | for (i = 0; i < depcount; ++i) |
2983 | { |
2984 | LT_DLFREE (names[i]); |
2985 | } |
2986 | |
2987 | cleanup: |
2988 | LT_DLFREE (names); |
2989 | /* restore the old search path */ |
2990 | if (user_search_path) { |
2991 | LT_DLFREE (user_search_path); |
2992 | user_search_path = save_search_path; |
2993 | } |
2994 | LT_DLMUTEX_UNLOCK (); |
2995 | |
2996 | #endif |
2997 | |
2998 | return errors; |
2999 | } |
3000 | |
3001 | static int |
3002 | unload_deplibs (handle) |
3003 | lt_dlhandle handle; |
3004 | { |
3005 | int i; |
3006 | int errors = 0; |
3007 | |
3008 | if (handle->depcount) |
3009 | { |
3010 | for (i = 0; i < handle->depcount; ++i) |
3011 | { |
3012 | if (!LT_DLIS_RESIDENT (handle->deplibs[i])) |
3013 | { |
3014 | errors += lt_dlclose (handle->deplibs[i]); |
3015 | } |
3016 | } |
ac40fd9e |
3017 | LT_DLFREE (handle->deplibs); |
d9898ee8 |
3018 | } |
3019 | |
3020 | return errors; |
3021 | } |
3022 | |
3023 | static int |
3024 | trim (dest, str) |
3025 | char **dest; |
3026 | const char *str; |
3027 | { |
3028 | /* remove the leading and trailing "'" from str |
3029 | and store the result in dest */ |
3030 | const char *end = strrchr (str, '\''); |
3031 | size_t len = LT_STRLEN (str); |
3032 | char *tmp; |
3033 | |
3034 | LT_DLFREE (*dest); |
3035 | |
3036 | if (!end) |
3037 | return 1; |
3038 | |
3039 | if (len > 3 && str[0] == '\'') |
3040 | { |
3041 | tmp = LT_EMALLOC (char, end - str); |
3042 | if (!tmp) |
3043 | return 1; |
3044 | |
3045 | strncpy(tmp, &str[1], (end - str) - 1); |
3046 | tmp[len-3] = LT_EOS_CHAR; |
3047 | *dest = tmp; |
3048 | } |
3049 | else |
3050 | { |
3051 | *dest = 0; |
3052 | } |
3053 | |
3054 | return 0; |
3055 | } |
3056 | |
3057 | static int |
3058 | free_vars (dlname, oldname, libdir, deplibs) |
3059 | char *dlname; |
3060 | char *oldname; |
3061 | char *libdir; |
3062 | char *deplibs; |
3063 | { |
3064 | LT_DLFREE (dlname); |
3065 | LT_DLFREE (oldname); |
3066 | LT_DLFREE (libdir); |
3067 | LT_DLFREE (deplibs); |
3068 | |
3069 | return 0; |
3070 | } |
3071 | |
3072 | static int |
3073 | try_dlopen (phandle, filename) |
3074 | lt_dlhandle *phandle; |
3075 | const char *filename; |
3076 | { |
3077 | const char * ext = 0; |
3078 | const char * saved_error = 0; |
3079 | char * canonical = 0; |
3080 | char * base_name = 0; |
3081 | char * dir = 0; |
3082 | char * name = 0; |
3083 | int errors = 0; |
3084 | lt_dlhandle newhandle; |
3085 | |
3086 | assert (phandle); |
3087 | assert (*phandle == 0); |
3088 | |
3089 | LT_DLMUTEX_GETERROR (saved_error); |
3090 | |
3091 | /* dlopen self? */ |
3092 | if (!filename) |
3093 | { |
3094 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); |
3095 | if (*phandle == 0) |
3096 | return 1; |
3097 | |
3098 | memset (*phandle, 0, sizeof(struct lt_dlhandle_struct)); |
3099 | newhandle = *phandle; |
3100 | |
3101 | /* lt_dlclose()ing yourself is very bad! Disallow it. */ |
3102 | LT_DLSET_FLAG (*phandle, LT_DLRESIDENT_FLAG); |
3103 | |
3104 | if (tryall_dlopen (&newhandle, 0) != 0) |
3105 | { |
3106 | LT_DLFREE (*phandle); |
3107 | return 1; |
3108 | } |
3109 | |
3110 | goto register_handle; |
3111 | } |
3112 | |
3113 | assert (filename && *filename); |
3114 | |
3115 | /* Doing this immediately allows internal functions to safely |
3116 | assume only canonicalized paths are passed. */ |
3117 | if (canonicalize_path (filename, &canonical) != 0) |
3118 | { |
3119 | ++errors; |
3120 | goto cleanup; |
3121 | } |
3122 | |
3123 | /* If the canonical module name is a path (relative or absolute) |
3124 | then split it into a directory part and a name part. */ |
3125 | base_name = strrchr (canonical, '/'); |
3126 | if (base_name) |
3127 | { |
3128 | size_t dirlen = (1+ base_name) - canonical; |
3129 | |
3130 | dir = LT_EMALLOC (char, 1+ dirlen); |
3131 | if (!dir) |
3132 | { |
3133 | ++errors; |
3134 | goto cleanup; |
3135 | } |
3136 | |
3137 | strncpy (dir, canonical, dirlen); |
3138 | dir[dirlen] = LT_EOS_CHAR; |
3139 | |
3140 | ++base_name; |
3141 | } |
3142 | else |
3143 | base_name = canonical; |
3144 | |
3145 | assert (base_name && *base_name); |
3146 | |
3147 | /* Check whether we are opening a libtool module (.la extension). */ |
3148 | ext = strrchr (base_name, '.'); |
3149 | if (ext && strcmp (ext, archive_ext) == 0) |
3150 | { |
3151 | /* this seems to be a libtool module */ |
3152 | FILE * file = 0; |
3153 | char * dlname = 0; |
3154 | char * old_name = 0; |
3155 | char * libdir = 0; |
3156 | char * deplibs = 0; |
3157 | char * line = 0; |
3158 | size_t line_len; |
3159 | |
3160 | /* if we can't find the installed flag, it is probably an |
3161 | installed libtool archive, produced with an old version |
3162 | of libtool */ |
3163 | int installed = 1; |
3164 | |
3165 | /* extract the module name from the file name */ |
3166 | name = LT_EMALLOC (char, ext - base_name + 1); |
3167 | if (!name) |
3168 | { |
3169 | ++errors; |
3170 | goto cleanup; |
3171 | } |
3172 | |
3173 | /* canonicalize the module name */ |
3174 | { |
3175 | size_t i; |
3176 | for (i = 0; i < ext - base_name; ++i) |
3177 | { |
3178 | if (isalnum ((int)(base_name[i]))) |
3179 | { |
3180 | name[i] = base_name[i]; |
3181 | } |
3182 | else |
3183 | { |
3184 | name[i] = '_'; |
3185 | } |
3186 | } |
3187 | name[ext - base_name] = LT_EOS_CHAR; |
3188 | } |
3189 | |
3190 | /* Now try to open the .la file. If there is no directory name |
3191 | component, try to find it first in user_search_path and then other |
3192 | prescribed paths. Otherwise (or in any case if the module was not |
3193 | yet found) try opening just the module name as passed. */ |
3194 | if (!dir) |
3195 | { |
3196 | const char *search_path; |
3197 | |
3198 | LT_DLMUTEX_LOCK (); |
3199 | search_path = user_search_path; |
3200 | if (search_path) |
3201 | file = find_file (user_search_path, base_name, &dir); |
3202 | LT_DLMUTEX_UNLOCK (); |
3203 | |
3204 | if (!file) |
3205 | { |
3206 | search_path = getenv (LTDL_SEARCHPATH_VAR); |
3207 | if (search_path) |
3208 | file = find_file (search_path, base_name, &dir); |
3209 | } |
3210 | |
3211 | #ifdef LTDL_SHLIBPATH_VAR |
3212 | if (!file) |
3213 | { |
3214 | search_path = getenv (LTDL_SHLIBPATH_VAR); |
3215 | if (search_path) |
3216 | file = find_file (search_path, base_name, &dir); |
3217 | } |
3218 | #endif |
3219 | #ifdef LTDL_SYSSEARCHPATH |
3220 | if (!file && sys_search_path) |
3221 | { |
3222 | file = find_file (sys_search_path, base_name, &dir); |
3223 | } |
3224 | #endif |
3225 | } |
ac40fd9e |
3226 | if (!file) |
d9898ee8 |
3227 | { |
ac40fd9e |
3228 | /* don't open .la files in current directory, root might get tricked to run a binary in a prepared directory */ |
3229 | if(!strncmp((filename + strlen(filename) - 3), LTDL_ARCHIVE_EXT,3) || strstr(filename,"/")) |
dd184caf |
3230 | file = fopen (filename, LT_READTEXT_MODE); |
d9898ee8 |
3231 | } |
3232 | |
3233 | /* If we didn't find the file by now, it really isn't there. Set |
3234 | the status flag, and bail out. */ |
3235 | if (!file) |
3236 | { |
3237 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
3238 | ++errors; |
3239 | goto cleanup; |
3240 | } |
3241 | |
3242 | line_len = LT_FILENAME_MAX; |
3243 | line = LT_EMALLOC (char, line_len); |
3244 | if (!line) |
3245 | { |
3246 | fclose (file); |
3247 | ++errors; |
3248 | goto cleanup; |
3249 | } |
3250 | |
3251 | /* read the .la file */ |
3252 | while (!feof (file)) |
3253 | { |
3254 | if (!fgets (line, (int) line_len, file)) |
3255 | { |
3256 | break; |
3257 | } |
3258 | |
3259 | /* Handle the case where we occasionally need to read a line |
3260 | that is longer than the initial buffer size. */ |
3261 | while ((line[LT_STRLEN(line) -1] != '\n') && (!feof (file))) |
3262 | { |
3263 | line = LT_DLREALLOC (char, line, line_len *2); |
3264 | if (!fgets (&line[line_len -1], (int) line_len +1, file)) |
3265 | { |
3266 | break; |
3267 | } |
3268 | line_len *= 2; |
3269 | } |
3270 | |
3271 | if (line[0] == '\n' || line[0] == '#') |
3272 | { |
3273 | continue; |
3274 | } |
3275 | |
3276 | #undef STR_DLNAME |
3277 | #define STR_DLNAME "dlname=" |
3278 | if (strncmp (line, STR_DLNAME, sizeof (STR_DLNAME) - 1) == 0) |
3279 | { |
3280 | errors += trim (&dlname, &line[sizeof (STR_DLNAME) - 1]); |
3281 | } |
3282 | |
3283 | #undef STR_OLD_LIBRARY |
3284 | #define STR_OLD_LIBRARY "old_library=" |
3285 | else if (strncmp (line, STR_OLD_LIBRARY, |
3286 | sizeof (STR_OLD_LIBRARY) - 1) == 0) |
3287 | { |
3288 | errors += trim (&old_name, &line[sizeof (STR_OLD_LIBRARY) - 1]); |
3289 | } |
3290 | #undef STR_LIBDIR |
3291 | #define STR_LIBDIR "libdir=" |
3292 | else if (strncmp (line, STR_LIBDIR, sizeof (STR_LIBDIR) - 1) == 0) |
3293 | { |
3294 | errors += trim (&libdir, &line[sizeof(STR_LIBDIR) - 1]); |
3295 | } |
3296 | |
3297 | #undef STR_DL_DEPLIBS |
3298 | #define STR_DL_DEPLIBS "dependency_libs=" |
3299 | else if (strncmp (line, STR_DL_DEPLIBS, |
3300 | sizeof (STR_DL_DEPLIBS) - 1) == 0) |
3301 | { |
3302 | errors += trim (&deplibs, &line[sizeof (STR_DL_DEPLIBS) - 1]); |
3303 | } |
3304 | else if (strcmp (line, "installed=yes\n") == 0) |
3305 | { |
3306 | installed = 1; |
3307 | } |
3308 | else if (strcmp (line, "installed=no\n") == 0) |
3309 | { |
3310 | installed = 0; |
3311 | } |
3312 | |
3313 | #undef STR_LIBRARY_NAMES |
3314 | #define STR_LIBRARY_NAMES "library_names=" |
3315 | else if (! dlname && strncmp (line, STR_LIBRARY_NAMES, |
3316 | sizeof (STR_LIBRARY_NAMES) - 1) == 0) |
3317 | { |
3318 | char *last_libname; |
3319 | errors += trim (&dlname, &line[sizeof (STR_LIBRARY_NAMES) - 1]); |
3320 | if (!errors |
3321 | && dlname |
3322 | && (last_libname = strrchr (dlname, ' ')) != 0) |
3323 | { |
3324 | last_libname = lt_estrdup (last_libname + 1); |
3325 | if (!last_libname) |
3326 | { |
3327 | ++errors; |
3328 | goto cleanup; |
3329 | } |
3330 | LT_DLMEM_REASSIGN (dlname, last_libname); |
3331 | } |
3332 | } |
3333 | |
3334 | if (errors) |
3335 | break; |
3336 | } |
3337 | |
3338 | fclose (file); |
3339 | LT_DLFREE (line); |
3340 | |
3341 | /* allocate the handle */ |
3342 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); |
3343 | if (*phandle == 0) |
3344 | ++errors; |
3345 | |
3346 | if (errors) |
3347 | { |
3348 | free_vars (dlname, old_name, libdir, deplibs); |
3349 | LT_DLFREE (*phandle); |
3350 | goto cleanup; |
3351 | } |
3352 | |
3353 | assert (*phandle); |
3354 | |
3355 | memset (*phandle, 0, sizeof(struct lt_dlhandle_struct)); |
3356 | if (load_deplibs (*phandle, deplibs) == 0) |
3357 | { |
3358 | newhandle = *phandle; |
3359 | /* find_module may replace newhandle */ |
3360 | if (find_module (&newhandle, dir, libdir, dlname, old_name, installed)) |
3361 | { |
3362 | unload_deplibs (*phandle); |
3363 | ++errors; |
3364 | } |
3365 | } |
3366 | else |
3367 | { |
3368 | ++errors; |
3369 | } |
3370 | |
3371 | free_vars (dlname, old_name, libdir, deplibs); |
3372 | if (errors) |
3373 | { |
3374 | LT_DLFREE (*phandle); |
3375 | goto cleanup; |
3376 | } |
3377 | |
3378 | if (*phandle != newhandle) |
3379 | { |
3380 | unload_deplibs (*phandle); |
3381 | } |
3382 | } |
3383 | else |
3384 | { |
3385 | /* not a libtool module */ |
3386 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); |
3387 | if (*phandle == 0) |
3388 | { |
3389 | ++errors; |
3390 | goto cleanup; |
3391 | } |
3392 | |
3393 | memset (*phandle, 0, sizeof (struct lt_dlhandle_struct)); |
3394 | newhandle = *phandle; |
3395 | |
3396 | /* If the module has no directory name component, try to find it |
3397 | first in user_search_path and then other prescribed paths. |
3398 | Otherwise (or in any case if the module was not yet found) try |
3399 | opening just the module name as passed. */ |
3400 | if ((dir || (!find_handle (user_search_path, base_name, &newhandle) |
3401 | && !find_handle (getenv (LTDL_SEARCHPATH_VAR), base_name, |
3402 | &newhandle) |
3403 | #ifdef LTDL_SHLIBPATH_VAR |
3404 | && !find_handle (getenv (LTDL_SHLIBPATH_VAR), base_name, |
3405 | &newhandle) |
3406 | #endif |
3407 | #ifdef LTDL_SYSSEARCHPATH |
3408 | && !find_handle (sys_search_path, base_name, &newhandle) |
3409 | #endif |
3410 | ))) |
3411 | { |
3412 | if (tryall_dlopen (&newhandle, filename) != 0) |
3413 | { |
3414 | newhandle = NULL; |
3415 | } |
3416 | } |
3417 | |
3418 | if (!newhandle) |
3419 | { |
3420 | LT_DLFREE (*phandle); |
3421 | ++errors; |
3422 | goto cleanup; |
3423 | } |
3424 | } |
3425 | |
3426 | register_handle: |
3427 | LT_DLMEM_REASSIGN (*phandle, newhandle); |
3428 | |
3429 | if ((*phandle)->info.ref_count == 0) |
3430 | { |
3431 | (*phandle)->info.ref_count = 1; |
3432 | LT_DLMEM_REASSIGN ((*phandle)->info.name, name); |
3433 | |
3434 | LT_DLMUTEX_LOCK (); |
3435 | (*phandle)->next = handles; |
3436 | handles = *phandle; |
3437 | LT_DLMUTEX_UNLOCK (); |
3438 | } |
3439 | |
3440 | LT_DLMUTEX_SETERROR (saved_error); |
3441 | |
3442 | cleanup: |
3443 | LT_DLFREE (dir); |
3444 | LT_DLFREE (name); |
3445 | LT_DLFREE (canonical); |
3446 | |
3447 | return errors; |
3448 | } |
3449 | |
3450 | lt_dlhandle |
3451 | lt_dlopen (filename) |
3452 | const char *filename; |
3453 | { |
3454 | lt_dlhandle handle = 0; |
3455 | |
3456 | /* Just incase we missed a code path in try_dlopen() that reports |
3457 | an error, but forgets to reset handle... */ |
3458 | if (try_dlopen (&handle, filename) != 0) |
3459 | return 0; |
3460 | |
3461 | return handle; |
3462 | } |
3463 | |
3464 | /* If the last error messge store was `FILE_NOT_FOUND', then return |
3465 | non-zero. */ |
3466 | static int |
3467 | file_not_found () |
3468 | { |
3469 | const char *error = 0; |
3470 | |
3471 | LT_DLMUTEX_GETERROR (error); |
3472 | if (error == LT_DLSTRERROR (FILE_NOT_FOUND)) |
3473 | return 1; |
3474 | |
3475 | return 0; |
3476 | } |
3477 | |
3478 | /* If FILENAME has an ARCHIVE_EXT or SHLIB_EXT extension, try to |
3479 | open the FILENAME as passed. Otherwise try appending ARCHIVE_EXT, |
3480 | and if a file is still not found try again with SHLIB_EXT appended |
3481 | instead. */ |
3482 | lt_dlhandle |
3483 | lt_dlopenext (filename) |
3484 | const char *filename; |
3485 | { |
3486 | lt_dlhandle handle = 0; |
3487 | char * tmp = 0; |
3488 | char * ext = 0; |
3489 | size_t len; |
3490 | int errors = 0; |
3491 | |
3492 | if (!filename) |
3493 | { |
3494 | return lt_dlopen (filename); |
3495 | } |
3496 | |
3497 | assert (filename); |
3498 | |
3499 | len = LT_STRLEN (filename); |
3500 | ext = strrchr (filename, '.'); |
3501 | |
3502 | /* If FILENAME already bears a suitable extension, there is no need |
3503 | to try appending additional extensions. */ |
3504 | if (ext && ((strcmp (ext, archive_ext) == 0) |
3505 | #ifdef LTDL_SHLIB_EXT |
3506 | || (strcmp (ext, shlib_ext) == 0) |
3507 | #endif |
3508 | )) |
3509 | { |
3510 | return lt_dlopen (filename); |
3511 | } |
3512 | |
3513 | /* First try appending ARCHIVE_EXT. */ |
3514 | tmp = LT_EMALLOC (char, len + LT_STRLEN (archive_ext) + 1); |
3515 | if (!tmp) |
3516 | return 0; |
3517 | |
3518 | strcpy (tmp, filename); |
3519 | strcat (tmp, archive_ext); |
3520 | errors = try_dlopen (&handle, tmp); |
3521 | |
3522 | /* If we found FILENAME, stop searching -- whether we were able to |
3523 | load the file as a module or not. If the file exists but loading |
3524 | failed, it is better to return an error message here than to |
3525 | report FILE_NOT_FOUND when the alternatives (foo.so etc) are not |
3526 | in the module search path. */ |
3527 | if (handle || ((errors > 0) && !file_not_found ())) |
3528 | { |
3529 | LT_DLFREE (tmp); |
3530 | return handle; |
3531 | } |
3532 | |
3533 | #ifdef LTDL_SHLIB_EXT |
3534 | /* Try appending SHLIB_EXT. */ |
3535 | if (LT_STRLEN (shlib_ext) > LT_STRLEN (archive_ext)) |
3536 | { |
3537 | LT_DLFREE (tmp); |
3538 | tmp = LT_EMALLOC (char, len + LT_STRLEN (shlib_ext) + 1); |
3539 | if (!tmp) |
3540 | return 0; |
3541 | |
3542 | strcpy (tmp, filename); |
3543 | } |
3544 | else |
3545 | { |
3546 | tmp[len] = LT_EOS_CHAR; |
3547 | } |
3548 | |
3549 | strcat(tmp, shlib_ext); |
3550 | errors = try_dlopen (&handle, tmp); |
3551 | |
3552 | /* As before, if the file was found but loading failed, return now |
3553 | with the current error message. */ |
3554 | if (handle || ((errors > 0) && !file_not_found ())) |
3555 | { |
3556 | LT_DLFREE (tmp); |
3557 | return handle; |
3558 | } |
3559 | #endif |
3560 | |
3561 | /* Still here? Then we really did fail to locate any of the file |
3562 | names we tried. */ |
3563 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
3564 | LT_DLFREE (tmp); |
3565 | return 0; |
3566 | } |
3567 | |
3568 | |
3569 | static int |
3570 | lt_argz_insert (pargz, pargz_len, before, entry) |
3571 | char **pargz; |
3572 | size_t *pargz_len; |
3573 | char *before; |
3574 | const char *entry; |
3575 | { |
3576 | error_t error; |
3577 | |
3578 | /* Prior to Sep 8, 2005, newlib had a bug where argz_insert(pargz, |
3579 | pargz_len, NULL, entry) failed with EINVAL. */ |
3580 | if (before) |
3581 | error = argz_insert (pargz, pargz_len, before, entry); |
3582 | else |
3583 | error = argz_append (pargz, pargz_len, entry, 1 + LT_STRLEN (entry)); |
3584 | |
3585 | if (error) |
3586 | { |
3587 | switch (error) |
3588 | { |
3589 | case ENOMEM: |
3590 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
3591 | break; |
3592 | default: |
3593 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); |
3594 | break; |
3595 | } |
3596 | return 1; |
3597 | } |
3598 | |
3599 | return 0; |
3600 | } |
3601 | |
3602 | static int |
3603 | lt_argz_insertinorder (pargz, pargz_len, entry) |
3604 | char **pargz; |
3605 | size_t *pargz_len; |
3606 | const char *entry; |
3607 | { |
3608 | char *before = 0; |
3609 | |
3610 | assert (pargz); |
3611 | assert (pargz_len); |
3612 | assert (entry && *entry); |
3613 | |
3614 | if (*pargz) |
3615 | while ((before = argz_next (*pargz, *pargz_len, before))) |
3616 | { |
3617 | int cmp = strcmp (entry, before); |
3618 | |
3619 | if (cmp < 0) break; |
3620 | if (cmp == 0) return 0; /* No duplicates! */ |
3621 | } |
3622 | |
3623 | return lt_argz_insert (pargz, pargz_len, before, entry); |
3624 | } |
3625 | |
3626 | static int |
3627 | lt_argz_insertdir (pargz, pargz_len, dirnam, dp) |
3628 | char **pargz; |
3629 | size_t *pargz_len; |
3630 | const char *dirnam; |
3631 | struct dirent *dp; |
3632 | { |
3633 | char *buf = 0; |
3634 | size_t buf_len = 0; |
3635 | char *end = 0; |
3636 | size_t end_offset = 0; |
3637 | size_t dir_len = 0; |
3638 | int errors = 0; |
3639 | |
3640 | assert (pargz); |
3641 | assert (pargz_len); |
3642 | assert (dp); |
3643 | |
3644 | dir_len = LT_STRLEN (dirnam); |
3645 | end = dp->d_name + LT_D_NAMLEN(dp); |
3646 | |
3647 | /* Ignore version numbers. */ |
3648 | { |
3649 | char *p; |
3650 | for (p = end; p -1 > dp->d_name; --p) |
3651 | if (strchr (".0123456789", p[-1]) == 0) |
3652 | break; |
3653 | |
3654 | if (*p == '.') |
3655 | end = p; |
3656 | } |
3657 | |
3658 | /* Ignore filename extension. */ |
3659 | { |
3660 | char *p; |
3661 | for (p = end -1; p > dp->d_name; --p) |
3662 | if (*p == '.') |
3663 | { |
3664 | end = p; |
3665 | break; |
3666 | } |
3667 | } |
3668 | |
3669 | /* Prepend the directory name. */ |
3670 | end_offset = end - dp->d_name; |
3671 | buf_len = dir_len + 1+ end_offset; |
3672 | buf = LT_EMALLOC (char, 1+ buf_len); |
3673 | if (!buf) |
3674 | return ++errors; |
3675 | |
3676 | assert (buf); |
3677 | |
3678 | strcpy (buf, dirnam); |
3679 | strcat (buf, "/"); |
3680 | strncat (buf, dp->d_name, end_offset); |
3681 | buf[buf_len] = LT_EOS_CHAR; |
3682 | |
3683 | /* Try to insert (in order) into ARGZ/ARGZ_LEN. */ |
3684 | if (lt_argz_insertinorder (pargz, pargz_len, buf) != 0) |
3685 | ++errors; |
3686 | |
3687 | LT_DLFREE (buf); |
3688 | |
3689 | return errors; |
3690 | } |
3691 | |
3692 | static int |
3693 | list_files_by_dir (dirnam, pargz, pargz_len) |
3694 | const char *dirnam; |
3695 | char **pargz; |
3696 | size_t *pargz_len; |
3697 | { |
3698 | DIR *dirp = 0; |
3699 | int errors = 0; |
3700 | |
3701 | assert (dirnam && *dirnam); |
3702 | assert (pargz); |
3703 | assert (pargz_len); |
3704 | assert (dirnam[LT_STRLEN(dirnam) -1] != '/'); |
3705 | |
3706 | dirp = opendir (dirnam); |
3707 | if (dirp) |
3708 | { |
3709 | struct dirent *dp = 0; |
3710 | |
3711 | while ((dp = readdir (dirp))) |
3712 | if (dp->d_name[0] != '.') |
3713 | if (lt_argz_insertdir (pargz, pargz_len, dirnam, dp)) |
3714 | { |
3715 | ++errors; |
3716 | break; |
3717 | } |
3718 | |
3719 | closedir (dirp); |
3720 | } |
3721 | else |
3722 | ++errors; |
3723 | |
3724 | return errors; |
3725 | } |
3726 | |
3727 | |
3728 | /* If there are any files in DIRNAME, call the function passed in |
3729 | DATA1 (with the name of each file and DATA2 as arguments). */ |
3730 | static int |
3731 | foreachfile_callback (dirname, data1, data2) |
3732 | char *dirname; |
3733 | lt_ptr data1; |
3734 | lt_ptr data2; |
3735 | { |
3736 | int (*func) LT_PARAMS((const char *filename, lt_ptr data)) |
3737 | = (int (*) LT_PARAMS((const char *filename, lt_ptr data))) data1; |
3738 | |
3739 | int is_done = 0; |
3740 | char *argz = 0; |
3741 | size_t argz_len = 0; |
3742 | |
3743 | if (list_files_by_dir (dirname, &argz, &argz_len) != 0) |
3744 | goto cleanup; |
3745 | if (!argz) |
3746 | goto cleanup; |
3747 | |
3748 | { |
3749 | char *filename = 0; |
3750 | while ((filename = argz_next (argz, argz_len, filename))) |
3751 | if ((is_done = (*func) (filename, data2))) |
3752 | break; |
3753 | } |
3754 | |
3755 | cleanup: |
3756 | LT_DLFREE (argz); |
3757 | |
3758 | return is_done; |
3759 | } |
3760 | |
3761 | |
3762 | /* Call FUNC for each unique extensionless file in SEARCH_PATH, along |
3763 | with DATA. The filenames passed to FUNC would be suitable for |
3764 | passing to lt_dlopenext. The extensions are stripped so that |
3765 | individual modules do not generate several entries (e.g. libfoo.la, |
3766 | libfoo.so, libfoo.so.1, libfoo.so.1.0.0). If SEARCH_PATH is NULL, |
3767 | then the same directories that lt_dlopen would search are examined. */ |
3768 | int |
3769 | lt_dlforeachfile (search_path, func, data) |
3770 | const char *search_path; |
3771 | int (*func) LT_PARAMS ((const char *filename, lt_ptr data)); |
3772 | lt_ptr data; |
3773 | { |
3774 | int is_done = 0; |
3775 | |
3776 | if (search_path) |
3777 | { |
3778 | /* If a specific path was passed, search only the directories |
3779 | listed in it. */ |
3780 | is_done = foreach_dirinpath (search_path, 0, |
3781 | foreachfile_callback, func, data); |
3782 | } |
3783 | else |
3784 | { |
3785 | /* Otherwise search the default paths. */ |
3786 | is_done = foreach_dirinpath (user_search_path, 0, |
3787 | foreachfile_callback, func, data); |
3788 | if (!is_done) |
3789 | { |
3790 | is_done = foreach_dirinpath (getenv("LTDL_LIBRARY_PATH"), 0, |
3791 | foreachfile_callback, func, data); |
3792 | } |
3793 | |
3794 | #ifdef LTDL_SHLIBPATH_VAR |
3795 | if (!is_done) |
3796 | { |
3797 | is_done = foreach_dirinpath (getenv(LTDL_SHLIBPATH_VAR), 0, |
3798 | foreachfile_callback, func, data); |
3799 | } |
3800 | #endif |
3801 | #ifdef LTDL_SYSSEARCHPATH |
3802 | if (!is_done) |
3803 | { |
3804 | is_done = foreach_dirinpath (getenv(LTDL_SYSSEARCHPATH), 0, |
3805 | foreachfile_callback, func, data); |
3806 | } |
3807 | #endif |
3808 | } |
3809 | |
3810 | return is_done; |
3811 | } |
3812 | |
3813 | int |
3814 | lt_dlclose (handle) |
3815 | lt_dlhandle handle; |
3816 | { |
3817 | lt_dlhandle cur, last; |
3818 | int errors = 0; |
3819 | |
3820 | LT_DLMUTEX_LOCK (); |
3821 | |
3822 | /* check whether the handle is valid */ |
3823 | last = cur = handles; |
3824 | while (cur && handle != cur) |
3825 | { |
3826 | last = cur; |
3827 | cur = cur->next; |
3828 | } |
3829 | |
3830 | if (!cur) |
3831 | { |
3832 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); |
3833 | ++errors; |
3834 | goto done; |
3835 | } |
3836 | |
3837 | handle->info.ref_count--; |
3838 | |
3839 | /* Note that even with resident modules, we must track the ref_count |
3840 | correctly incase the user decides to reset the residency flag |
3841 | later (even though the API makes no provision for that at the |
3842 | moment). */ |
3843 | if (handle->info.ref_count <= 0 && !LT_DLIS_RESIDENT (handle)) |
3844 | { |
3845 | lt_user_data data = handle->loader->dlloader_data; |
3846 | |
3847 | if (handle != handles) |
3848 | { |
3849 | last->next = handle->next; |
3850 | } |
3851 | else |
3852 | { |
3853 | handles = handle->next; |
3854 | } |
3855 | |
3856 | errors += handle->loader->module_close (data, handle->module); |
3857 | errors += unload_deplibs(handle); |
3858 | |
3859 | /* It is up to the callers to free the data itself. */ |
3860 | LT_DLFREE (handle->caller_data); |
3861 | |
3862 | LT_DLFREE (handle->info.filename); |
3863 | LT_DLFREE (handle->info.name); |
3864 | LT_DLFREE (handle); |
3865 | |
3866 | goto done; |
3867 | } |
3868 | |
3869 | if (LT_DLIS_RESIDENT (handle)) |
3870 | { |
3871 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CLOSE_RESIDENT_MODULE)); |
3872 | ++errors; |
3873 | } |
3874 | |
3875 | done: |
3876 | LT_DLMUTEX_UNLOCK (); |
3877 | |
3878 | return errors; |
3879 | } |
3880 | |
3881 | lt_ptr |
3882 | lt_dlsym (handle, symbol) |
3883 | lt_dlhandle handle; |
3884 | const char *symbol; |
3885 | { |
3886 | size_t lensym; |
3887 | char lsym[LT_SYMBOL_LENGTH]; |
3888 | char *sym; |
3889 | lt_ptr address; |
3890 | lt_user_data data; |
3891 | |
3892 | if (!handle) |
3893 | { |
3894 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); |
3895 | return 0; |
3896 | } |
3897 | |
3898 | if (!symbol) |
3899 | { |
3900 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
3901 | return 0; |
3902 | } |
3903 | |
3904 | lensym = LT_STRLEN (symbol) + LT_STRLEN (handle->loader->sym_prefix) |
3905 | + LT_STRLEN (handle->info.name); |
3906 | |
3907 | if (lensym + LT_SYMBOL_OVERHEAD < LT_SYMBOL_LENGTH) |
3908 | { |
3909 | sym = lsym; |
3910 | } |
3911 | else |
3912 | { |
3913 | sym = LT_EMALLOC (char, lensym + LT_SYMBOL_OVERHEAD + 1); |
3914 | if (!sym) |
3915 | { |
3916 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (BUFFER_OVERFLOW)); |
3917 | return 0; |
3918 | } |
3919 | } |
3920 | |
3921 | data = handle->loader->dlloader_data; |
3922 | if (handle->info.name) |
3923 | { |
3924 | const char *saved_error; |
3925 | |
3926 | LT_DLMUTEX_GETERROR (saved_error); |
3927 | |
3928 | /* this is a libtool module */ |
3929 | if (handle->loader->sym_prefix) |
3930 | { |
3931 | strcpy(sym, handle->loader->sym_prefix); |
3932 | strcat(sym, handle->info.name); |
3933 | } |
3934 | else |
3935 | { |
3936 | strcpy(sym, handle->info.name); |
3937 | } |
3938 | |
3939 | strcat(sym, "_LTX_"); |
3940 | strcat(sym, symbol); |
3941 | |
3942 | /* try "modulename_LTX_symbol" */ |
3943 | address = handle->loader->find_sym (data, handle->module, sym); |
3944 | if (address) |
3945 | { |
3946 | if (sym != lsym) |
3947 | { |
3948 | LT_DLFREE (sym); |
3949 | } |
3950 | return address; |
3951 | } |
3952 | LT_DLMUTEX_SETERROR (saved_error); |
3953 | } |
3954 | |
3955 | /* otherwise try "symbol" */ |
3956 | if (handle->loader->sym_prefix) |
3957 | { |
3958 | strcpy(sym, handle->loader->sym_prefix); |
3959 | strcat(sym, symbol); |
3960 | } |
3961 | else |
3962 | { |
3963 | strcpy(sym, symbol); |
3964 | } |
3965 | |
3966 | address = handle->loader->find_sym (data, handle->module, sym); |
3967 | if (sym != lsym) |
3968 | { |
3969 | LT_DLFREE (sym); |
3970 | } |
3971 | |
3972 | return address; |
3973 | } |
3974 | |
3975 | const char * |
3976 | lt_dlerror () |
3977 | { |
3978 | const char *error; |
3979 | |
3980 | LT_DLMUTEX_GETERROR (error); |
3981 | LT_DLMUTEX_SETERROR (0); |
3982 | |
3983 | return error ? error : NULL; |
3984 | } |
3985 | |
3986 | static int |
3987 | lt_dlpath_insertdir (ppath, before, dir) |
3988 | char **ppath; |
3989 | char *before; |
3990 | const char *dir; |
3991 | { |
3992 | int errors = 0; |
3993 | char *canonical = 0; |
3994 | char *argz = 0; |
3995 | size_t argz_len = 0; |
3996 | |
3997 | assert (ppath); |
3998 | assert (dir && *dir); |
3999 | |
4000 | if (canonicalize_path (dir, &canonical) != 0) |
4001 | { |
4002 | ++errors; |
4003 | goto cleanup; |
4004 | } |
4005 | |
4006 | assert (canonical && *canonical); |
4007 | |
4008 | /* If *PPATH is empty, set it to DIR. */ |
4009 | if (*ppath == 0) |
4010 | { |
4011 | assert (!before); /* BEFORE cannot be set without PPATH. */ |
4012 | assert (dir); /* Without DIR, don't call this function! */ |
4013 | |
4014 | *ppath = lt_estrdup (dir); |
4015 | if (*ppath == 0) |
4016 | ++errors; |
4017 | |
4018 | return errors; |
4019 | } |
4020 | |
4021 | assert (ppath && *ppath); |
4022 | |
4023 | if (argzize_path (*ppath, &argz, &argz_len) != 0) |
4024 | { |
4025 | ++errors; |
4026 | goto cleanup; |
4027 | } |
4028 | |
4029 | /* Convert BEFORE into an equivalent offset into ARGZ. This only works |
4030 | if *PPATH is already canonicalized, and hence does not change length |
4031 | with respect to ARGZ. We canonicalize each entry as it is added to |
4032 | the search path, and don't call this function with (uncanonicalized) |
4033 | user paths, so this is a fair assumption. */ |
4034 | if (before) |
4035 | { |
4036 | assert (*ppath <= before); |
4037 | assert (before - *ppath <= strlen (*ppath)); |
4038 | |
4039 | before = before - *ppath + argz; |
4040 | } |
4041 | |
4042 | if (lt_argz_insert (&argz, &argz_len, before, dir) != 0) |
4043 | { |
4044 | ++errors; |
4045 | goto cleanup; |
4046 | } |
4047 | |
4048 | argz_stringify (argz, argz_len, LT_PATHSEP_CHAR); |
4049 | LT_DLMEM_REASSIGN (*ppath, argz); |
4050 | |
4051 | cleanup: |
4052 | LT_DLFREE (canonical); |
4053 | LT_DLFREE (argz); |
4054 | |
4055 | return errors; |
4056 | } |
4057 | |
4058 | int |
4059 | lt_dladdsearchdir (search_dir) |
4060 | const char *search_dir; |
4061 | { |
4062 | int errors = 0; |
4063 | |
4064 | if (search_dir && *search_dir) |
4065 | { |
4066 | LT_DLMUTEX_LOCK (); |
4067 | if (lt_dlpath_insertdir (&user_search_path, 0, search_dir) != 0) |
4068 | ++errors; |
4069 | LT_DLMUTEX_UNLOCK (); |
4070 | } |
4071 | |
4072 | return errors; |
4073 | } |
4074 | |
4075 | int |
4076 | lt_dlinsertsearchdir (before, search_dir) |
4077 | const char *before; |
4078 | const char *search_dir; |
4079 | { |
4080 | int errors = 0; |
4081 | |
4082 | if (before) |
4083 | { |
4084 | LT_DLMUTEX_LOCK (); |
4085 | if ((before < user_search_path) |
4086 | || (before >= user_search_path + LT_STRLEN (user_search_path))) |
4087 | { |
4088 | LT_DLMUTEX_UNLOCK (); |
4089 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_POSITION)); |
4090 | return 1; |
4091 | } |
4092 | LT_DLMUTEX_UNLOCK (); |
4093 | } |
4094 | |
4095 | if (search_dir && *search_dir) |
4096 | { |
4097 | LT_DLMUTEX_LOCK (); |
4098 | if (lt_dlpath_insertdir (&user_search_path, |
4099 | (char *) before, search_dir) != 0) |
4100 | { |
4101 | ++errors; |
4102 | } |
4103 | LT_DLMUTEX_UNLOCK (); |
4104 | } |
4105 | |
4106 | return errors; |
4107 | } |
4108 | |
4109 | int |
4110 | lt_dlsetsearchpath (search_path) |
4111 | const char *search_path; |
4112 | { |
4113 | int errors = 0; |
4114 | |
4115 | LT_DLMUTEX_LOCK (); |
4116 | LT_DLFREE (user_search_path); |
4117 | LT_DLMUTEX_UNLOCK (); |
4118 | |
4119 | if (!search_path || !LT_STRLEN (search_path)) |
4120 | { |
4121 | return errors; |
4122 | } |
4123 | |
4124 | LT_DLMUTEX_LOCK (); |
4125 | if (canonicalize_path (search_path, &user_search_path) != 0) |
4126 | ++errors; |
4127 | LT_DLMUTEX_UNLOCK (); |
4128 | |
4129 | return errors; |
4130 | } |
4131 | |
4132 | const char * |
4133 | lt_dlgetsearchpath () |
4134 | { |
4135 | const char *saved_path; |
4136 | |
4137 | LT_DLMUTEX_LOCK (); |
4138 | saved_path = user_search_path; |
4139 | LT_DLMUTEX_UNLOCK (); |
4140 | |
4141 | return saved_path; |
4142 | } |
4143 | |
4144 | int |
4145 | lt_dlmakeresident (handle) |
4146 | lt_dlhandle handle; |
4147 | { |
4148 | int errors = 0; |
4149 | |
4150 | if (!handle) |
4151 | { |
4152 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); |
4153 | ++errors; |
4154 | } |
4155 | else |
4156 | { |
4157 | LT_DLSET_FLAG (handle, LT_DLRESIDENT_FLAG); |
4158 | } |
4159 | |
4160 | return errors; |
4161 | } |
4162 | |
4163 | int |
4164 | lt_dlisresident (handle) |
4165 | lt_dlhandle handle; |
4166 | { |
4167 | if (!handle) |
4168 | { |
4169 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); |
4170 | return -1; |
4171 | } |
4172 | |
4173 | return LT_DLIS_RESIDENT (handle); |
4174 | } |
4175 | |
4176 | |
4177 | |
4178 | \f |
4179 | /* --- MODULE INFORMATION --- */ |
4180 | |
4181 | const lt_dlinfo * |
4182 | lt_dlgetinfo (handle) |
4183 | lt_dlhandle handle; |
4184 | { |
4185 | if (!handle) |
4186 | { |
4187 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); |
4188 | return 0; |
4189 | } |
4190 | |
4191 | return &(handle->info); |
4192 | } |
4193 | |
4194 | lt_dlhandle |
4195 | lt_dlhandle_next (place) |
4196 | lt_dlhandle place; |
4197 | { |
4198 | return place ? place->next : handles; |
4199 | } |
4200 | |
4201 | int |
4202 | lt_dlforeach (func, data) |
4203 | int (*func) LT_PARAMS((lt_dlhandle handle, lt_ptr data)); |
4204 | lt_ptr data; |
4205 | { |
4206 | int errors = 0; |
4207 | lt_dlhandle cur; |
4208 | |
4209 | LT_DLMUTEX_LOCK (); |
4210 | |
4211 | cur = handles; |
4212 | while (cur) |
4213 | { |
4214 | lt_dlhandle tmp = cur; |
4215 | |
4216 | cur = cur->next; |
4217 | if ((*func) (tmp, data)) |
4218 | { |
4219 | ++errors; |
4220 | break; |
4221 | } |
4222 | } |
4223 | |
4224 | LT_DLMUTEX_UNLOCK (); |
4225 | |
4226 | return errors; |
4227 | } |
4228 | |
4229 | lt_dlcaller_id |
4230 | lt_dlcaller_register () |
4231 | { |
4232 | static lt_dlcaller_id last_caller_id = 0; |
4233 | int result; |
4234 | |
4235 | LT_DLMUTEX_LOCK (); |
4236 | result = ++last_caller_id; |
4237 | LT_DLMUTEX_UNLOCK (); |
4238 | |
4239 | return result; |
4240 | } |
4241 | |
4242 | lt_ptr |
4243 | lt_dlcaller_set_data (key, handle, data) |
4244 | lt_dlcaller_id key; |
4245 | lt_dlhandle handle; |
4246 | lt_ptr data; |
4247 | { |
4248 | int n_elements = 0; |
4249 | lt_ptr stale = (lt_ptr) 0; |
4250 | int i; |
4251 | |
4252 | /* This needs to be locked so that the caller data can be updated |
4253 | simultaneously by different threads. */ |
4254 | LT_DLMUTEX_LOCK (); |
4255 | |
4256 | if (handle->caller_data) |
4257 | while (handle->caller_data[n_elements].key) |
4258 | ++n_elements; |
4259 | |
4260 | for (i = 0; i < n_elements; ++i) |
4261 | { |
4262 | if (handle->caller_data[i].key == key) |
4263 | { |
4264 | stale = handle->caller_data[i].data; |
4265 | break; |
4266 | } |
4267 | } |
4268 | |
4269 | /* Ensure that there is enough room in this handle's caller_data |
4270 | array to accept a new element (and an empty end marker). */ |
4271 | if (i == n_elements) |
4272 | { |
4273 | lt_caller_data *temp |
4274 | = LT_DLREALLOC (lt_caller_data, handle->caller_data, 2+ n_elements); |
4275 | |
4276 | if (!temp) |
4277 | { |
4278 | stale = 0; |
4279 | goto done; |
4280 | } |
4281 | |
4282 | handle->caller_data = temp; |
4283 | |
4284 | /* We only need this if we needed to allocate a new caller_data. */ |
4285 | handle->caller_data[i].key = key; |
4286 | handle->caller_data[1+ i].key = 0; |
4287 | } |
4288 | |
4289 | handle->caller_data[i].data = data; |
4290 | |
4291 | done: |
4292 | LT_DLMUTEX_UNLOCK (); |
4293 | |
4294 | return stale; |
4295 | } |
4296 | |
4297 | lt_ptr |
4298 | lt_dlcaller_get_data (key, handle) |
4299 | lt_dlcaller_id key; |
4300 | lt_dlhandle handle; |
4301 | { |
4302 | lt_ptr result = (lt_ptr) 0; |
4303 | |
4304 | /* This needs to be locked so that the caller data isn't updated by |
4305 | another thread part way through this function. */ |
4306 | LT_DLMUTEX_LOCK (); |
4307 | |
4308 | /* Locate the index of the element with a matching KEY. */ |
4309 | { |
4310 | int i; |
4311 | for (i = 0; handle->caller_data[i].key; ++i) |
4312 | { |
4313 | if (handle->caller_data[i].key == key) |
4314 | { |
4315 | result = handle->caller_data[i].data; |
4316 | break; |
4317 | } |
4318 | } |
4319 | } |
4320 | |
4321 | LT_DLMUTEX_UNLOCK (); |
4322 | |
4323 | return result; |
4324 | } |
4325 | |
4326 | |
4327 | \f |
4328 | /* --- USER MODULE LOADER API --- */ |
4329 | |
4330 | |
4331 | int |
4332 | lt_dlloader_add (place, dlloader, loader_name) |
4333 | lt_dlloader *place; |
4334 | const struct lt_user_dlloader *dlloader; |
4335 | const char *loader_name; |
4336 | { |
4337 | int errors = 0; |
4338 | lt_dlloader *node = 0, *ptr = 0; |
4339 | |
4340 | if ((dlloader == 0) /* diagnose null parameters */ |
4341 | || (dlloader->module_open == 0) |
4342 | || (dlloader->module_close == 0) |
4343 | || (dlloader->find_sym == 0)) |
4344 | { |
4345 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); |
4346 | return 1; |
4347 | } |
4348 | |
4349 | /* Create a new dlloader node with copies of the user callbacks. */ |
4350 | node = LT_EMALLOC (lt_dlloader, 1); |
4351 | if (!node) |
4352 | return 1; |
4353 | |
4354 | node->next = 0; |
4355 | node->loader_name = loader_name; |
4356 | node->sym_prefix = dlloader->sym_prefix; |
4357 | node->dlloader_exit = dlloader->dlloader_exit; |
4358 | node->module_open = dlloader->module_open; |
4359 | node->module_close = dlloader->module_close; |
4360 | node->find_sym = dlloader->find_sym; |
4361 | node->dlloader_data = dlloader->dlloader_data; |
4362 | |
4363 | LT_DLMUTEX_LOCK (); |
4364 | if (!loaders) |
4365 | { |
4366 | /* If there are no loaders, NODE becomes the list! */ |
4367 | loaders = node; |
4368 | } |
4369 | else if (!place) |
4370 | { |
4371 | /* If PLACE is not set, add NODE to the end of the |
4372 | LOADERS list. */ |
4373 | for (ptr = loaders; ptr->next; ptr = ptr->next) |
4374 | { |
4375 | /*NOWORK*/; |
4376 | } |
4377 | |
4378 | ptr->next = node; |
4379 | } |
4380 | else if (loaders == place) |
4381 | { |
4382 | /* If PLACE is the first loader, NODE goes first. */ |
4383 | node->next = place; |
4384 | loaders = node; |
4385 | } |
4386 | else |
4387 | { |
4388 | /* Find the node immediately preceding PLACE. */ |
4389 | for (ptr = loaders; ptr->next != place; ptr = ptr->next) |
4390 | { |
4391 | /*NOWORK*/; |
4392 | } |
4393 | |
4394 | if (ptr->next != place) |
4395 | { |
4396 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); |
4397 | ++errors; |
4398 | } |
4399 | else |
4400 | { |
4401 | /* Insert NODE between PTR and PLACE. */ |
4402 | node->next = place; |
4403 | ptr->next = node; |
4404 | } |
4405 | } |
4406 | |
4407 | LT_DLMUTEX_UNLOCK (); |
4408 | |
4409 | return errors; |
4410 | } |
4411 | |
4412 | int |
4413 | lt_dlloader_remove (loader_name) |
4414 | const char *loader_name; |
4415 | { |
4416 | lt_dlloader *place = lt_dlloader_find (loader_name); |
4417 | lt_dlhandle handle; |
4418 | int errors = 0; |
4419 | |
4420 | if (!place) |
4421 | { |
4422 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); |
4423 | return 1; |
4424 | } |
4425 | |
4426 | LT_DLMUTEX_LOCK (); |
4427 | |
4428 | /* Fail if there are any open modules which use this loader. */ |
4429 | for (handle = handles; handle; handle = handle->next) |
4430 | { |
4431 | if (handle->loader == place) |
4432 | { |
4433 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (REMOVE_LOADER)); |
4434 | ++errors; |
4435 | goto done; |
4436 | } |
4437 | } |
4438 | |
4439 | if (place == loaders) |
4440 | { |
4441 | /* PLACE is the first loader in the list. */ |
4442 | loaders = loaders->next; |
4443 | } |
4444 | else |
4445 | { |
4446 | /* Find the loader before the one being removed. */ |
4447 | lt_dlloader *prev; |
4448 | for (prev = loaders; prev->next; prev = prev->next) |
4449 | { |
4450 | if (!strcmp (prev->next->loader_name, loader_name)) |
4451 | { |
4452 | break; |
4453 | } |
4454 | } |
4455 | |
4456 | place = prev->next; |
4457 | prev->next = prev->next->next; |
4458 | } |
4459 | |
4460 | if (place->dlloader_exit) |
4461 | { |
4462 | errors = place->dlloader_exit (place->dlloader_data); |
4463 | } |
4464 | |
4465 | LT_DLFREE (place); |
4466 | |
4467 | done: |
4468 | LT_DLMUTEX_UNLOCK (); |
4469 | |
4470 | return errors; |
4471 | } |
4472 | |
4473 | lt_dlloader * |
4474 | lt_dlloader_next (place) |
4475 | lt_dlloader *place; |
4476 | { |
4477 | lt_dlloader *next; |
4478 | |
4479 | LT_DLMUTEX_LOCK (); |
4480 | next = place ? place->next : loaders; |
4481 | LT_DLMUTEX_UNLOCK (); |
4482 | |
4483 | return next; |
4484 | } |
4485 | |
4486 | const char * |
4487 | lt_dlloader_name (place) |
4488 | lt_dlloader *place; |
4489 | { |
4490 | const char *name = 0; |
4491 | |
4492 | if (place) |
4493 | { |
4494 | LT_DLMUTEX_LOCK (); |
4495 | name = place ? place->loader_name : 0; |
4496 | LT_DLMUTEX_UNLOCK (); |
4497 | } |
4498 | else |
4499 | { |
4500 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); |
4501 | } |
4502 | |
4503 | return name; |
4504 | } |
4505 | |
4506 | lt_user_data * |
4507 | lt_dlloader_data (place) |
4508 | lt_dlloader *place; |
4509 | { |
4510 | lt_user_data *data = 0; |
4511 | |
4512 | if (place) |
4513 | { |
4514 | LT_DLMUTEX_LOCK (); |
4515 | data = place ? &(place->dlloader_data) : 0; |
4516 | LT_DLMUTEX_UNLOCK (); |
4517 | } |
4518 | else |
4519 | { |
4520 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); |
4521 | } |
4522 | |
4523 | return data; |
4524 | } |
4525 | |
4526 | lt_dlloader * |
4527 | lt_dlloader_find (loader_name) |
4528 | const char *loader_name; |
4529 | { |
4530 | lt_dlloader *place = 0; |
4531 | |
4532 | LT_DLMUTEX_LOCK (); |
4533 | for (place = loaders; place; place = place->next) |
4534 | { |
4535 | if (strcmp (place->loader_name, loader_name) == 0) |
4536 | { |
4537 | break; |
4538 | } |
4539 | } |
4540 | LT_DLMUTEX_UNLOCK (); |
4541 | |
4542 | return place; |
4543 | } |