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