![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ltdl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / sql / pgsql / libltdl|
Return to ltdl.c CVS log | Up to [parser3project] / sql / pgsql / libltdl |
1.1 parser 1: /* ltdl.c -- system independent dlopen wrapper
2: Copyright (C) 1998-1999 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 Library 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 Library General Public License,
12: if you distribute this file as part of a program that uses GNU libtool
13: to create libraries and programs, 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: Library General Public License for more details.
20:
21: You should have received a copy of the GNU Library General Public
22: License along with this library; if not, write to the Free Software
23: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24: 02111-1307 USA
25: */
26:
27: #define _LTDL_COMPILE_
28:
29: #include "config.h"
30:
31: #if HAVE_STRING_H
32: #include <string.h>
33: #endif
34:
35: #if HAVE_STRINGS_H
36: #include <strings.h>
37: #endif
38:
39: #if HAVE_CTYPE_H
40: #include <ctype.h>
41: #endif
42:
43: #if HAVE_MALLOC_H
44: #include <malloc.h>
45: #endif
46:
47: #if HAVE_MEMORY_H
48: #include <memory.h>
49: #endif
50:
51: #if HAVE_STDLIB_H
52: #include <stdlib.h>
53: #endif
54:
55: #if HAVE_STDIO_H
56: #include <stdio.h>
57: #endif
58:
59: #include "ltdl.h"
60:
61: /* max. filename length */
62: #ifndef LTDL_FILENAME_MAX
63: #define LTDL_FILENAME_MAX 1024
64: #endif
65:
66: #undef LTDL_READTEXT_MODE
67: /* fopen() mode flags for reading a text file */
68: #ifdef _WIN32
69: #define LTDL_READTEXT_MODE "rt"
70: #else
71: #define LTDL_READTEXT_MODE "r"
72: #endif
73:
74: #undef LTDL_SYMBOL_LENGTH
75: /* This is the maximum symbol size that won't require malloc/free */
76: #define LTDL_SYMBOL_LENGTH 128
77:
78: #undef LTDL_SYMBOL_OVERHEAD
79: /* This accounts for the _LTX_ separator */
80: #define LTDL_SYMBOL_OVERHEAD 5
81:
82: static const char objdir[] = LTDL_OBJDIR;
83: #ifdef LTDL_SHLIB_EXT
84: static const char shlib_ext[] = LTDL_SHLIB_EXT;
85: #endif
86:
87: static const char unknown_error[] = "unknown error";
88: static const char dlopen_not_supported_error[] = "dlopen support not available";
89: static const char file_not_found_error[] = "file not found";
90: static const char no_symbols_error[] = "no symbols defined";
91: static const char cannot_open_error[] = "can't open the module";
92: static const char cannot_close_error[] = "can't close the module";
93: static const char symbol_error[] = "symbol not found";
94: static const char memory_error[] = "not enough memory";
95: static const char invalid_handle_error[] = "invalid handle";
96: static const char buffer_overflow_error[] = "internal buffer overflow";
97: static const char shutdown_error[] = "library already shutdown";
98:
99: #ifndef HAVE_PRELOADED_SYMBOLS
100: /* If libtool won't define it, we'd better do */
101: const lt_dlsymlist lt_preloaded_symbols[1] = { { 0, 0 } };
102: #endif
103:
104: static const char *last_error = 0;
105:
106: lt_ptr_t (*lt_dlmalloc) LTDL_PARAMS((size_t size)) = (lt_ptr_t(*)LTDL_PARAMS((size_t)))malloc;
107: void (*lt_dlfree) LTDL_PARAMS((lt_ptr_t ptr)) = (void(*)LTDL_PARAMS((lt_ptr_t)))free;
108:
109: typedef struct lt_dltype_t {
110: struct lt_dltype_t *next;
111: const char *sym_prefix; /* prefix for symbols */
112: int (*mod_init) LTDL_PARAMS((void));
113: int (*mod_exit) LTDL_PARAMS((void));
114: int (*lib_open) LTDL_PARAMS((lt_dlhandle handle, const char *filename));
115: int (*lib_close) LTDL_PARAMS((lt_dlhandle handle));
116: lt_ptr_t (*find_sym) LTDL_PARAMS((lt_dlhandle handle, const char *symbol));
117: } lt_dltype_t;
118:
119: #define LTDL_TYPE_TOP 0
120:
121: typedef struct lt_dlhandle_t {
122: struct lt_dlhandle_t *next;
123: lt_dltype_t *type; /* dlopening interface */
124: char *filename; /* file name */
125: char *name; /* module name */
126: int usage; /* usage */
127: int depcount; /* number of dependencies */
128: lt_dlhandle *deplibs; /* dependencies */
129: lt_ptr_t handle; /* system handle */
130: lt_ptr_t system; /* system specific data */
131: } lt_dlhandle_t;
132:
133: #undef strdup
134: #define strdup xstrdup
135:
136: static inline char *
137: strdup(str)
138: const char *str;
139: {
140: char *tmp;
141:
142: if (!str)
143: return 0;
144: tmp = (char*) lt_dlmalloc(strlen(str)+1);
145: if (tmp)
146: strcpy(tmp, str);
147: return tmp;
148: }
149:
150: #if ! HAVE_STRCHR
151:
152: # if HAVE_INDEX
153:
154: # define strchr index
155:
156: # else
157:
158: # define strchr xstrchr
159:
160: static inline const char*
161: strchr(str, ch)
162: const char *str;
163: int ch;
164: {
165: const char *p;
166:
167: for (p = str; *p != (char)ch && *p != '\0'; p++)
168: /*NOWORK*/;
169:
170: return (*p == (char)ch) ? p : 0;
171: }
172:
173: # endif
174:
175: #endif
176:
177: #if ! HAVE_STRRCHR
178:
179: # if HAVE_RINDEX
180:
181: # define strrchr rindex
182:
183: # else
184:
185: # define strrchr xstrrchr
186:
187: static inline const char*
188: strrchr(str, ch)
189: const char *str;
190: int ch;
191: {
192: const char *p;
193:
194: for (p = str; *p != '\0'; p++)
195: /*NOWORK*/;
196:
197: while (*p != (char)ch && p >= str)
198: p--;
199:
200: return (*p == (char)ch) ? p : 0;
201: }
202:
203: # endif
204:
205: #endif
206:
207: #if HAVE_LIBDL
208:
209: /* dynamic linking with dlopen/dlsym */
210:
211: #if HAVE_DLFCN_H
212: # include <dlfcn.h>
213: #endif
214:
215: #ifdef RTLD_GLOBAL
216: # define LTDL_GLOBAL RTLD_GLOBAL
217: #else
218: # ifdef DL_GLOBAL
219: # define LTDL_GLOBAL DL_GLOBAL
220: # else
221: # define LTDL_GLOBAL 0
222: # endif
223: #endif
224:
225: /* We may have to define LTDL_LAZY_OR_NOW in the command line if we
226: find out it does not work in some platform. */
227: #ifndef LTDL_LAZY_OR_NOW
228: # ifdef RTLD_LAZY
229: # define LTDL_LAZY_OR_NOW RTLD_LAZY
230: # else
231: # ifdef DL_LAZY
232: # define LTDL_LAZY_OR_NOW DL_LAZY
233: # else
234: # ifdef RTLD_NOW
235: # define LTDL_LAZY_OR_NOW RTLD_NOW
236: # else
237: # ifdef DL_NOW
238: # define LTDL_LAZY_OR_NOW DL_NOW
239: # else
240: # define LTDL_LAZY_OR_NOW 0
241: # endif
242: # endif
243: # endif
244: # endif
245: #endif
246:
247: static int
248: sys_dl_init LTDL_PARAMS((void))
249: {
250: return 0;
251: }
252:
253: static int
254: sys_dl_exit LTDL_PARAMS((void))
255: {
256: return 0;
257: }
258:
259: static int
260: sys_dl_open (handle, filename)
261: lt_dlhandle handle;
262: const char *filename;
263: {
264: handle->handle = dlopen(filename, LTDL_GLOBAL | LTDL_LAZY_OR_NOW);
265: if (!handle->handle) {
266: #if HAVE_DLERROR
267: last_error = dlerror();
268: #else
269: last_error = cannot_open_error;
270: #endif
271: return 1;
272: }
273: return 0;
274: }
275:
276: static int
277: sys_dl_close (handle)
278: lt_dlhandle handle;
279: {
280: if (dlclose(handle->handle) != 0) {
281: #if HAVE_DLERROR
282: last_error = dlerror();
283: #else
284: last_error = cannot_close_error;
285: #endif
286: return 1;
287: }
288: return 0;
289: }
290:
291: static lt_ptr_t
292: sys_dl_sym (handle, symbol)
293: lt_dlhandle handle;
294: const char *symbol;
295: {
296: lt_ptr_t address = dlsym(handle->handle, symbol);
297:
298: if (!address)
299: #if HAVE_DLERROR
300: last_error = dlerror();
301: #else
302: last_error = symbol_error;
303: #endif
304: return address;
305: }
306:
307: static
308: lt_dltype_t
309: #ifdef NEED_USCORE
310: sys_dl = { LTDL_TYPE_TOP, "_", sys_dl_init, sys_dl_exit,
311: sys_dl_open, sys_dl_close, sys_dl_sym };
312: #else
313: sys_dl = { LTDL_TYPE_TOP, 0, sys_dl_init, sys_dl_exit,
314: sys_dl_open, sys_dl_close, sys_dl_sym };
315: #endif
316:
317: #undef LTDL_TYPE_TOP
318: #define LTDL_TYPE_TOP &sys_dl
319:
320: #endif
321:
322: #if HAVE_SHL_LOAD
323:
324: /* dynamic linking with shl_load (HP-UX) (comments from gmodule) */
325:
326: #ifdef HAVE_DL_H
327: #include <dl.h>
328: #endif
329:
330: /* some flags are missing on some systems, so we provide
331: * harmless defaults.
332: *
333: * Mandatory:
334: * BIND_IMMEDIATE - Resolve symbol references when the library is loaded.
335: * BIND_DEFERRED - Delay code symbol resolution until actual reference.
336: *
337: * Optionally:
338: * BIND_FIRST - Place the library at the head of the symbol search order.
339: * BIND_NONFATAL - The default BIND_IMMEDIATE behavior is to treat all unsatisfied
340: * symbols as fatal. This flag allows binding of unsatisfied code
341: * symbols to be deferred until use.
342: * [Perl: For certain libraries, like DCE, deferred binding often
343: * causes run time problems. Adding BIND_NONFATAL to BIND_IMMEDIATE
344: * still allows unresolved references in situations like this.]
345: * BIND_NOSTART - Do not call the initializer for the shared library when the
346: * library is loaded, nor on a future call to shl_unload().
347: * BIND_VERBOSE - Print verbose messages concerning possible unsatisfied symbols.
348: *
349: * hp9000s700/hp9000s800:
350: * BIND_RESTRICTED - Restrict symbols visible by the library to those present at
351: * library load time.
352: * DYNAMIC_PATH - Allow the loader to dynamically search for the library specified
353: * by the path argument.
354: */
355:
356: #ifndef DYNAMIC_PATH
357: #define DYNAMIC_PATH 0
358: #endif /* DYNAMIC_PATH */
359: #ifndef BIND_RESTRICTED
360: #define BIND_RESTRICTED 0
361: #endif /* BIND_RESTRICTED */
362:
363: #define LTDL_BIND_FLAGS (BIND_IMMEDIATE | BIND_NONFATAL | DYNAMIC_PATH)
364:
365: static int
366: sys_shl_init LTDL_PARAMS((void))
367: {
368: return 0;
369: }
370:
371: static int
372: sys_shl_exit LTDL_PARAMS((void))
373: {
374: return 0;
375: }
376:
377: static int
378: sys_shl_open (handle, filename)
379: lt_dlhandle handle;
380: const char *filename;
381: {
382: handle->handle = shl_load(filename, LTDL_BIND_FLAGS, 0L);
383: if (!handle->handle) {
384: last_error = cannot_open_error;
385: return 1;
386: }
387: return 0;
388: }
389:
390: static int
391: sys_shl_close (handle)
392: lt_dlhandle handle;
393: {
394: if (shl_unload((shl_t) (handle->handle)) != 0) {
395: last_error = cannot_close_error;
396: return 1;
397: }
398: return 0;
399: }
400:
401: static lt_ptr_t
402: sys_shl_sym (handle, symbol)
403: lt_dlhandle handle;
404: const char *symbol;
405: {
406: lt_ptr_t address;
407:
408: if (handle->handle && shl_findsym((shl_t*) &(handle->handle),
409: symbol, TYPE_UNDEFINED, &address) == 0)
410: if (address)
411: return address;
412: last_error = symbol_error;
413: return 0;
414: }
415:
416: static
417: lt_dltype_t
418: sys_shl = { LTDL_TYPE_TOP, 0, sys_shl_init, sys_shl_exit,
419: sys_shl_open, sys_shl_close, sys_shl_sym };
420:
421: #undef LTDL_TYPE_TOP
422: #define LTDL_TYPE_TOP &sys_shl
423:
424: #endif
425:
426: #if HAVE_DLD
427:
428: /* dynamic linking with dld */
429:
430: #if HAVE_DLD_H
431: #include <dld.h>
432: #endif
433:
434: static int
435: sys_dld_init LTDL_PARAMS((void))
436: {
437: return 0;
438: }
439:
440: static int
441: sys_dld_exit LTDL_PARAMS((void))
442: {
443: return 0;
444: }
445:
446: static int
447: sys_dld_open (handle, filename)
448: lt_dlhandle handle;
449: const char *filename;
450: {
451: handle->handle = strdup(filename);
452: if (!handle->handle) {
453: last_error = memory_error;
454: return 1;
455: }
456: if (dld_link(filename) != 0) {
457: last_error = cannot_open_error;
458: lt_dlfree(handle->handle);
459: return 1;
460: }
461: return 0;
462: }
463:
464: static int
465: sys_dld_close (handle)
466: lt_dlhandle handle;
467: {
468: if (dld_unlink_by_file((char*)(handle->handle), 1) != 0) {
469: last_error = cannot_close_error;
470: return 1;
471: }
472: lt_dlfree(handle->filename);
473: return 0;
474: }
475:
476: static lt_ptr_t
477: sys_dld_sym (handle, symbol)
478: lt_dlhandle handle;
479: const char *symbol;
480: {
481: lt_ptr_t address = dld_get_func(symbol);
482:
483: if (!address)
484: last_error = symbol_error;
485: return address;
486: }
487:
488: static
489: lt_dltype_t
490: sys_dld = { LTDL_TYPE_TOP, 0, sys_dld_init, sys_dld_exit,
491: sys_dld_open, sys_dld_close, sys_dld_sym };
492:
493: #undef LTDL_TYPE_TOP
494: #define LTDL_TYPE_TOP &sys_dld
495:
496: #endif
497:
498: #ifdef _WIN32
499:
500: /* dynamic linking for Win32 */
501:
502: #include <windows.h>
503:
504: static int
505: sys_wll_init LTDL_PARAMS((void))
506: {
507: return 0;
508: }
509:
510: static int
511: sys_wll_exit LTDL_PARAMS((void))
512: {
513: return 0;
514: }
515:
516: /* Forward declaration; required to implement handle search below. */
517: static lt_dlhandle handles;
518:
519: static int
520: sys_wll_open (handle, filename)
521: lt_dlhandle handle;
522: const char *filename;
523: {
524: lt_dlhandle cur;
525: char *searchname = NULL;
526: char *ext = strrchr(filename, '.');
527:
528: if (ext) {
529: /* FILENAME already has an extension. */
530: searchname = strdup(filename);
531: } else {
532: /* Append a `.' to stop Windows from adding an
533: implicit `.dll' extension. */
534: searchname = (char*)lt_dlmalloc(2+ strlen(filename));
535: strcpy(searchname, filename);
536: strcat(searchname, ".");
537: }
538:
539: handle->handle = LoadLibrary(searchname);
540: lt_dlfree(searchname);
541:
542: /* libltdl expects this function to fail if it is unable
543: to physically load the library. Sadly, LoadLibrary
544: will search the loaded libraries for a match and return
545: one of them if the path search load fails.
546:
547: We check whether LoadLibrary is returning a handle to
548: an already loaded module, and simulate failure if we
549: find one. */
550: cur = handles;
551: while (cur) {
552: if (!cur->handle) {
553: cur = 0;
554: break;
555: }
556: if (cur->handle == handle->handle)
557: break;
558: cur = cur->next;
559: }
560:
561: if (cur || !handle->handle) {
562: last_error = cannot_open_error;
563: return 1;
564: }
565:
566: return 0;
567: }
568:
569: static int
570: sys_wll_close (handle)
571: lt_dlhandle handle;
572: {
573: if (FreeLibrary(handle->handle) == 0) {
574: last_error = cannot_close_error;
575: return 1;
576: }
577: return 0;
578: }
579:
580: static lt_ptr_t
581: sys_wll_sym (handle, symbol)
582: lt_dlhandle handle;
583: const char *symbol;
584: {
585: lt_ptr_t address = GetProcAddress(handle->handle, symbol);
586:
587: if (!address)
588: last_error = symbol_error;
589: return address;
590: }
591:
592: static
593: lt_dltype_t
594: sys_wll = { LTDL_TYPE_TOP, 0, sys_wll_init, sys_wll_exit,
595: sys_wll_open, sys_wll_close, sys_wll_sym };
596:
597: #undef LTDL_TYPE_TOP
598: #define LTDL_TYPE_TOP &sys_wll
599:
600: #endif
601:
602: #ifdef __BEOS__
603:
604: /* dynamic linking for BeOS */
605:
606: #include <kernel/image.h>
607:
608: static int
609: sys_bedl_init LTDL_PARAMS((void))
610: {
611: return 0;
612: }
613:
614: static int
615: sys_bedl_exit LTDL_PARAMS((void))
616: {
617: return 0;
618: }
619:
620: static int
621: sys_bedl_open (handle, filename)
622: lt_dlhandle handle;
623: const char *filename;
624: {
625: image_id image = 0;
626:
627: if (filename) {
628: image = load_add_on(filename);
629: } else {
630: image_info info;
631: int32 cookie = 0;
632: if (get_next_image_info(0, &cookie, &info) == B_OK)
633: image = load_add_on(info.name);
634: }
635: if (image <= 0) {
636: last_error = cannot_open_error;
637: return 1;
638: }
639: handle->handle = (void*) image;
640: return 0;
641: }
642:
643: static int
644: sys_bedl_close (handle)
645: lt_dlhandle handle;
646: {
647: if (unload_add_on((image_id)handle->handle) != B_OK) {
648: last_error = cannot_close_error;
649: return 1;
650: }
651: return 0;
652: }
653:
654: static lt_ptr_t
655: sys_bedl_sym (handle, symbol)
656: lt_dlhandle handle;
657: const char *symbol;
658: {
659: lt_ptr_t address = 0;
660: image_id image = (image_id)handle->handle;
661:
662: if (get_image_symbol(image, symbol, B_SYMBOL_TYPE_ANY,
663: &address) != B_OK) {
664: last_error = symbol_error;
665: return 0;
666: }
667: return address;
668: }
669:
670: static
671: lt_dltype_t
672: sys_bedl = { LTDL_TYPE_TOP, 0, sys_bedl_init, sys_bedl_exit,
673: sys_bedl_open, sys_bedl_close, sys_bedl_sym };
674:
675: #undef LTDL_TYPE_TOP
676: #define LTDL_TYPE_TOP &sys_bedl
677:
678: #endif
679:
680: /* emulate dynamic linking using preloaded_symbols */
681:
682: typedef struct lt_dlsymlists_t {
683: struct lt_dlsymlists_t *next;
684: const lt_dlsymlist *syms;
685: } lt_dlsymlists_t;
686:
687: static const lt_dlsymlist *default_preloaded_symbols = 0;
688: static lt_dlsymlists_t *preloaded_symbols = 0;
689:
690: static int
691: presym_init LTDL_PARAMS((void))
692: {
693: preloaded_symbols = 0;
694: if (default_preloaded_symbols)
695: return lt_dlpreload(default_preloaded_symbols);
696: return 0;
697: }
698:
699: static int
700: presym_free_symlists LTDL_PARAMS((void))
701: {
702: lt_dlsymlists_t *lists = preloaded_symbols;
703:
704: while (lists) {
705: lt_dlsymlists_t *tmp = lists;
706:
707: lists = lists->next;
708: lt_dlfree(tmp);
709: }
710: preloaded_symbols = 0;
711: return 0;
712: }
713:
714: static int
715: presym_exit LTDL_PARAMS((void))
716: {
717: presym_free_symlists();
718: return 0;
719: }
720:
721: static int
722: presym_add_symlist (preloaded)
723: const lt_dlsymlist *preloaded;
724: {
725: lt_dlsymlists_t *tmp;
726: lt_dlsymlists_t *lists = preloaded_symbols;
727:
728: while (lists) {
729: if (lists->syms == preloaded)
730: return 0;
731: lists = lists->next;
732: }
733:
734: tmp = (lt_dlsymlists_t*) lt_dlmalloc(sizeof(lt_dlsymlists_t));
735: if (!tmp) {
736: last_error = memory_error;
737: return 1;
738: }
739: tmp->syms = preloaded;
740: tmp->next = 0;
741: if (!preloaded_symbols)
742: preloaded_symbols = tmp;
743: else {
744: /* append to the end */
745: lists = preloaded_symbols;
746: while (lists->next)
747: lists = lists->next;
748: lists->next = tmp;
749: }
750: return 0;
751: }
752:
753: static int
754: presym_open (handle, filename)
755: lt_dlhandle handle;
756: const char *filename;
757: {
758: lt_dlsymlists_t *lists = preloaded_symbols;
759:
760: if (!lists) {
761: last_error = no_symbols_error;
762: return 1;
763: }
764: if (!filename)
765: filename = "@PROGRAM@";
766: while (lists) {
767: const lt_dlsymlist *syms = lists->syms;
768:
769: while (syms->name) {
770: if (!syms->address &&
771: strcmp(syms->name, filename) == 0) {
772: handle->handle = (lt_ptr_t) syms;
773: return 0;
774: }
775: syms++;
776: }
777: lists = lists->next;
778: }
779: last_error = file_not_found_error;
780: return 1;
781: }
782:
783: static int
784: presym_close (handle)
785: lt_dlhandle handle;
786: {
787: /* Just to silence gcc -Wall */
788: handle = 0;
789: return 0;
790: }
791:
792: static lt_ptr_t
793: presym_sym (handle, symbol)
794: lt_dlhandle handle;
795: const char *symbol;
796: {
797: lt_dlsymlist *syms = (lt_dlsymlist*)(handle->handle);
798:
799: syms++;
800: while (syms->address) {
801: if (strcmp(syms->name, symbol) == 0)
802: return syms->address;
803: syms++;
804: }
805: last_error = symbol_error;
806: return 0;
807: }
808:
809: static
810: lt_dltype_t
811: presym = { LTDL_TYPE_TOP, 0, presym_init, presym_exit,
812: presym_open, presym_close, presym_sym };
813:
814: #undef LTDL_TYPE_TOP
815: #define LTDL_TYPE_TOP &presym
816:
817: static char *user_search_path = 0;
818: static lt_dlhandle handles = 0;
819: static int initialized = 0;
820:
821: static lt_dltype_t *types = LTDL_TYPE_TOP;
822: #undef LTDL_TYPE_TOP
823:
824: int
825: lt_dlinit LTDL_PARAMS((void))
826: {
827: /* initialize libltdl */
828: lt_dltype_t **type = &types;
829: int typecount = 0;
830:
831: if (initialized) { /* Initialize only at first call. */
832: initialized++;
833: return 0;
834: }
835: handles = 0;
836: user_search_path = 0; /* empty search path */
837:
838: while (*type) {
839: if ((*type)->mod_init())
840: *type = (*type)->next; /* Remove it from the list */
841: else {
842: type = &(*type)->next; /* Keep it */
843: typecount++;
844: }
845: }
846: if (typecount == 0) {
847: last_error = dlopen_not_supported_error;
848: return 1;
849: }
850: last_error = 0;
851: initialized = 1;
852: return 0;
853: }
854:
855: int
856: lt_dlpreload (preloaded)
857: const lt_dlsymlist *preloaded;
858: {
859: if (preloaded)
860: return presym_add_symlist(preloaded);
861: presym_free_symlists();
862: if (default_preloaded_symbols)
863: return lt_dlpreload(default_preloaded_symbols);
864: return 0;
865: }
866:
867: int
868: lt_dlpreload_default (preloaded)
869: const lt_dlsymlist *preloaded;
870: {
871: default_preloaded_symbols = preloaded;
872: return 0;
873: }
874:
875: int
876: lt_dlexit LTDL_PARAMS((void))
877: {
878: /* shut down libltdl */
879: lt_dltype_t *type = types;
880: int errors;
881:
882: if (!initialized) {
883: last_error = shutdown_error;
884: return 1;
885: }
886: if (initialized != 1) { /* shut down only at last call. */
887: initialized--;
888: return 0;
889: }
890: /* close all modules */
891: errors = 0;
892: while (handles) {
893: /* FIXME: what if a module depends on another one? */
894: if (lt_dlclose(handles))
895: errors++;
896: }
897: initialized = 0;
898: while (type) {
899: if (type->mod_exit())
900: errors++;
901: type = type->next;
902: }
903: return errors;
904: }
905:
906: static int
907: tryall_dlopen (handle, filename)
908: lt_dlhandle *handle;
909: const char *filename;
910: {
911: lt_dlhandle cur;
912: lt_dltype_t *type = types;
913: const char *saved_error = last_error;
914:
915: /* check whether the module was already opened */
916: cur = handles;
917: while (cur) {
918: if (!cur->filename && !filename)
919: break;
920: if (cur->filename && filename &&
921: strcmp(cur->filename, filename) == 0)
922: break;
923: cur = cur->next;
924: }
925: if (cur) {
926: cur->usage++;
927: *handle = cur;
928: return 0;
929: }
930:
931: cur = *handle;
932: if (filename) {
933: cur->filename = strdup(filename);
934: if (!cur->filename) {
935: last_error = memory_error;
936: return 1;
937: }
938: } else
939: cur->filename = 0;
940: while (type) {
941: if (type->lib_open(cur, filename) == 0)
942: break;
943: type = type->next;
944: }
945: if (!type) {
946: if (cur->filename)
947: lt_dlfree(cur->filename);
948: return 1;
949: }
950: cur->type = type;
951: last_error = saved_error;
952: return 0;
953: }
954:
955: static int
956: find_module (handle, dir, libdir, dlname, old_name, installed)
957: lt_dlhandle *handle;
958: const char *dir;
959: const char *libdir;
960: const char *dlname;
961: const char *old_name;
962: int installed;
963: {
964: int error;
965: char *filename;
966: /* try to open the old library first; if it was dlpreopened,
967: we want the preopened version of it, even if a dlopenable
968: module is available */
969: if (old_name && tryall_dlopen(handle, old_name) == 0)
970: return 0;
971: /* try to open the dynamic library */
972: if (dlname) {
973: /* try to open the installed module */
974: if (installed && libdir) {
975: filename = (char*)
976: lt_dlmalloc(strlen(libdir)+1+strlen(dlname)+1);
977: if (!filename) {
978: last_error = memory_error;
979: return 1;
980: }
981: strcpy(filename, libdir);
982: strcat(filename, "/");
983: strcat(filename, dlname);
984: error = tryall_dlopen(handle, filename) == 0;
985: lt_dlfree(filename);
986: if (error)
987: return 0;
988: }
989: /* try to open the not-installed module */
990: if (!installed) {
991: filename = (char*)
992: lt_dlmalloc((dir ? strlen(dir) : 0)
993: + strlen(objdir) + strlen(dlname) + 1);
994: if (!filename) {
995: last_error = memory_error;
996: return 1;
997: }
998: if (dir)
999: strcpy(filename, dir);
1000: else
1001: *filename = 0;
1002: strcat(filename, objdir);
1003: strcat(filename, dlname);
1004:
1005: error = tryall_dlopen(handle, filename) == 0;
1006: lt_dlfree(filename);
1007: if (error)
1008: return 0;
1009: }
1010: /* hmm, maybe it was moved to another directory */
1011: {
1012: filename = (char*)
1013: lt_dlmalloc((dir ? strlen(dir) : 0)
1014: + strlen(dlname) + 1);
1015: if (dir)
1016: strcpy(filename, dir);
1017: else
1018: *filename = 0;
1019: strcat(filename, dlname);
1020: error = tryall_dlopen(handle, filename) == 0;
1021: lt_dlfree(filename);
1022: if (error)
1023: return 0;
1024: }
1025: }
1026: last_error = file_not_found_error;
1027: return 1;
1028: }
1029:
1030: static lt_ptr_t
1031: find_file (basename, search_path, pdir, handle)
1032: const char *basename;
1033: const char *search_path;
1034: char **pdir;
1035: lt_dlhandle *handle;
1036: {
1037: /* when handle != NULL search a library, otherwise a file */
1038: /* return NULL on failure, otherwise the file/handle */
1039:
1040: char *filename = 0;
1041: int filenamesize = 0;
1042: const char *next = search_path;
1043: int lenbase = strlen(basename);
1044:
1045: if (!next || !*next) {
1046: last_error = file_not_found_error;
1047: return 0;
1048: }
1049: while (next) {
1050: int lendir;
1051: const char *cur = next;
1052:
1053: next = strchr(cur, ':');
1054: if (!next)
1055: next = cur + strlen(cur);
1056: lendir = next - cur;
1057: if (*next == ':')
1058: ++next;
1059: else
1060: next = 0;
1061: if (lendir == 0)
1062: continue;
1063: if (lendir + 1 + lenbase >= filenamesize) {
1064: if (filename)
1065: lt_dlfree(filename);
1066: filenamesize = lendir + 1 + lenbase + 1;
1067: filename = (char*) lt_dlmalloc(filenamesize);
1068: if (!filename) {
1069: last_error = memory_error;
1070: return 0;
1071: }
1072: }
1073: strncpy(filename, cur, lendir);
1074: if (filename[lendir-1] != '/')
1075: filename[lendir++] = '/';
1076: strcpy(filename+lendir, basename);
1077: if (handle) {
1078: if (tryall_dlopen(handle, filename) == 0) {
1079: lt_dlfree(filename);
1080: return (lt_ptr_t) handle;
1081: }
1082: } else {
1083: FILE *file = fopen(filename, LTDL_READTEXT_MODE);
1084: if (file) {
1085: if (*pdir)
1086: lt_dlfree(*pdir);
1087: filename[lendir] = '\0';
1088: *pdir = strdup(filename);
1089: if (!*pdir) {
1090: /* We could have even avoided the
1091: strdup, but there would be some
1092: memory overhead. */
1093: *pdir = filename;
1094: } else
1095: lt_dlfree(filename);
1096: return (lt_ptr_t) file;
1097: }
1098: }
1099: }
1100: if (filename)
1101: lt_dlfree(filename);
1102: last_error = file_not_found_error;
1103: return 0;
1104: }
1105:
1106: static int
1107: load_deplibs(handle, deplibs)
1108: lt_dlhandle handle;
1109: const char *deplibs;
1110: {
1111: /* FIXME: load deplibs */
1112: handle->depcount = 0;
1113: handle->deplibs = 0;
1114: /* Just to silence gcc -Wall */
1115: deplibs = 0;
1116: return 0;
1117: }
1118:
1119: static int
1120: unload_deplibs(handle)
1121: lt_dlhandle handle;
1122: {
1123: /* FIXME: unload deplibs */
1124: /* Just to silence gcc -Wall */
1125: handle = 0;
1126: return 0;
1127: }
1128:
1129: static inline int
1130: trim (dest, str)
1131: char **dest;
1132: const char *str;
1133: {
1134: /* remove the leading and trailing "'" from str
1135: and store the result in dest */
1136: char *tmp;
1137: const char *end = strrchr(str, '\'');
1138: int len = strlen(str);
1139:
1140: if (*dest)
1141: lt_dlfree(*dest);
1142: if (len > 3 && str[0] == '\'') {
1143: tmp = (char*) lt_dlmalloc(end - str);
1144: if (!tmp) {
1145: last_error = memory_error;
1146: return 1;
1147: }
1148: strncpy(tmp, &str[1], (end - str) - 1);
1149: tmp[len-3] = '\0';
1150: *dest = tmp;
1151: } else
1152: *dest = 0;
1153: return 0;
1154: }
1155:
1156: static inline int
1157: free_vars(dir, name, dlname, oldname, libdir, deplibs)
1158: char *dir;
1159: char *name;
1160: char *dlname;
1161: char *oldname;
1162: char *libdir;
1163: char *deplibs;
1164: {
1165: if (dir)
1166: lt_dlfree(dir);
1167: if (name)
1168: lt_dlfree(name);
1169: if (dlname)
1170: lt_dlfree(dlname);
1171: if (oldname)
1172: lt_dlfree(oldname);
1173: if (libdir)
1174: lt_dlfree(libdir);
1175: if (deplibs)
1176: lt_dlfree(deplibs);
1177: return 0;
1178: }
1179:
1180: lt_dlhandle
1181: lt_dlopen (filename)
1182: const char *filename;
1183: {
1184: lt_dlhandle handle, newhandle;
1185: const char *basename, *ext;
1186: const char *saved_error = last_error;
1187: char *dir = 0, *name = 0;
1188:
1189: if (!filename) {
1190: handle = (lt_dlhandle) lt_dlmalloc(sizeof(lt_dlhandle_t));
1191: if (!handle) {
1192: last_error = memory_error;
1193: return 0;
1194: }
1195: handle->usage = 0;
1196: handle->depcount = 0;
1197: handle->deplibs = 0;
1198: newhandle = handle;
1199: if (tryall_dlopen(&newhandle, 0) != 0) {
1200: lt_dlfree(handle);
1201: return 0;
1202: }
1203: goto register_handle;
1204: }
1205: basename = strrchr(filename, '/');
1206: if (basename) {
1207: basename++;
1208: dir = (char*) lt_dlmalloc(basename - filename + 1);
1209: if (!dir) {
1210: last_error = memory_error;
1211: return 0;
1212: }
1213: strncpy(dir, filename, basename - filename);
1214: dir[basename - filename] = '\0';
1215: } else
1216: basename = filename;
1217: /* check whether we open a libtool module (.la extension) */
1218: ext = strrchr(basename, '.');
1219: if (ext && strcmp(ext, ".la") == 0) {
1220: /* this seems to be a libtool module */
1221: FILE *file;
1222: int i;
1223: char *dlname = 0, *old_name = 0;
1224: char *libdir = 0, *deplibs = 0;
1225: char *line;
1226: int error = 0;
1227: /* if we can't find the installed flag, it is probably an
1228: installed libtool archive, produced with an old version
1229: of libtool */
1230: int installed = 1;
1231:
1232: /* extract the module name from the file name */
1233: name = (char*) lt_dlmalloc(ext - basename + 1);
1234: if (!name) {
1235: last_error = memory_error;
1236: if (dir)
1237: lt_dlfree(dir);
1238: return 0;
1239: }
1240: /* canonicalize the module name */
1241: for (i = 0; i < ext - basename; i++)
1242: if (isalnum((int)(basename[i])))
1243: name[i] = basename[i];
1244: else
1245: name[i] = '_';
1246: name[ext - basename] = '\0';
1247: /* now try to open the .la file */
1248: file = fopen(filename, LTDL_READTEXT_MODE);
1249: if (!file)
1250: last_error = file_not_found_error;
1251: if (!file && !dir) {
1252: /* try other directories */
1253: file = (FILE*) find_file(basename,
1254: user_search_path,
1255: &dir, 0);
1256: if (!file)
1257: file = (FILE*) find_file(basename,
1258: getenv("LTDL_LIBRARY_PATH"),
1259: &dir, 0);
1260: #ifdef LTDL_SHLIBPATH_VAR
1261: if (!file)
1262: file = (FILE*) find_file(basename,
1263: getenv(LTDL_SHLIBPATH_VAR),
1264: &dir, 0);
1265: #endif
1266: }
1267: if (!file) {
1268: if (name)
1269: lt_dlfree(name);
1270: if (dir)
1271: lt_dlfree(dir);
1272: return 0;
1273: }
1274: line = (char*) lt_dlmalloc(LTDL_FILENAME_MAX);
1275: if (!line) {
1276: fclose(file);
1277: last_error = memory_error;
1278: return 0;
1279: }
1280: /* read the .la file */
1281: while (!feof(file)) {
1282: if (!fgets(line, LTDL_FILENAME_MAX, file))
1283: break;
1284: if (line[0] == '\n' || line[0] == '#')
1285: continue;
1286: # undef STR_DLNAME
1287: # define STR_DLNAME "dlname="
1288: if (strncmp(line, STR_DLNAME,
1289: sizeof(STR_DLNAME) - 1) == 0)
1290: error = trim(&dlname,
1291: &line[sizeof(STR_DLNAME) - 1]);
1292: else
1293: # undef STR_OLD_LIBRARY
1294: # define STR_OLD_LIBRARY "old_library="
1295: if (strncmp(line, STR_OLD_LIBRARY,
1296: sizeof(STR_OLD_LIBRARY) - 1) == 0)
1297: error = trim(&old_name,
1298: &line[sizeof(STR_OLD_LIBRARY) - 1]);
1299: else
1300: # undef STR_LIBDIR
1301: # define STR_LIBDIR "libdir="
1302: if (strncmp(line, STR_LIBDIR,
1303: sizeof(STR_LIBDIR) - 1) == 0)
1304: error = trim(&libdir,
1305: &line[sizeof(STR_LIBDIR) - 1]);
1306: else
1307: # undef STR_DL_DEPLIBS
1308: # define STR_DL_DEPLIBS "dl_dependency_libs="
1309: if (strncmp(line, STR_DL_DEPLIBS,
1310: sizeof(STR_DL_DEPLIBS) - 1) == 0)
1311: error = trim(&deplibs,
1312: &line[sizeof(STR_DL_DEPLIBS) - 1]);
1313: else
1314: if (strcmp(line, "installed=yes\n") == 0)
1315: installed = 1;
1316: else
1317: if (strcmp(line, "installed=no\n") == 0)
1318: installed = 0;
1319: if (error)
1320: break;
1321: }
1322: fclose(file);
1323: lt_dlfree(line);
1324: /* allocate the handle */
1325: handle = (lt_dlhandle) lt_dlmalloc(sizeof(lt_dlhandle_t));
1326: if (!handle || error) {
1327: if (handle)
1328: lt_dlfree(handle);
1329: if (!error)
1330: last_error = memory_error;
1331: free_vars(name, dir, dlname, old_name, libdir, deplibs);
1332: return 0;
1333: }
1334: handle->usage = 0;
1335: if (load_deplibs(handle, deplibs) == 0) {
1336: newhandle = handle;
1337: /* find_module may replace newhandle */
1338: if (find_module(&newhandle, dir, libdir,
1339: dlname, old_name, installed)) {
1340: unload_deplibs(handle);
1341: error = 1;
1342: }
1343: } else
1344: error = 1;
1345: if (error) {
1346: lt_dlfree(handle);
1347: free_vars(name, dir, dlname, old_name, libdir, deplibs);
1348: return 0;
1349: }
1350: if (handle != newhandle) {
1351: unload_deplibs(handle);
1352: }
1353: } else {
1354: /* not a libtool module */
1355: handle = (lt_dlhandle) lt_dlmalloc(sizeof(lt_dlhandle_t));
1356: if (!handle) {
1357: last_error = memory_error;
1358: if (dir)
1359: lt_dlfree(dir);
1360: return 0;
1361: }
1362: handle->usage = 0;
1363: /* non-libtool modules don't have dependencies */
1364: handle->depcount = 0;
1365: handle->deplibs = 0;
1366: newhandle = handle;
1367: if (tryall_dlopen(&newhandle, filename)
1368: && (dir
1369: || (!find_file(basename, user_search_path,
1370: 0, &newhandle)
1371: && !find_file(basename,
1372: getenv("LTDL_LIBRARY_PATH"),
1373: 0, &newhandle)
1374: #ifdef LTDL_SHLIBPATH_VAR
1375: && !find_file(basename,
1376: getenv(LTDL_SHLIBPATH_VAR),
1377: 0, &newhandle)
1378: #endif
1379: ))) {
1380: lt_dlfree(handle);
1381: if (dir)
1382: lt_dlfree(dir);
1383: return 0;
1384: }
1385: }
1386: register_handle:
1387: if (newhandle != handle) {
1388: lt_dlfree(handle);
1389: handle = newhandle;
1390: }
1391: if (!handle->usage) {
1392: handle->usage = 1;
1393: handle->name = name;
1394: handle->next = handles;
1395: handles = handle;
1396: } else if (name)
1397: lt_dlfree(name);
1398: if (dir)
1399: lt_dlfree(dir);
1400: last_error = saved_error;
1401: return handle;
1402: }
1403:
1404: lt_dlhandle
1405: lt_dlopenext (filename)
1406: const char *filename;
1407: {
1408: lt_dlhandle handle;
1409: char *tmp;
1410: int len;
1411: const char *saved_error = last_error;
1412:
1413: if (!filename)
1414: return lt_dlopen(filename);
1415: len = strlen(filename);
1416: if (!len) {
1417: last_error = file_not_found_error;
1418: return 0;
1419: }
1420: /* try the normal file name */
1421: handle = lt_dlopen(filename);
1422: if (handle)
1423: return handle;
1424: /* try "filename.la" */
1425: tmp = (char*) lt_dlmalloc(len+4);
1426: if (!tmp) {
1427: last_error = memory_error;
1428: return 0;
1429: }
1430: strcpy(tmp, filename);
1431: strcat(tmp, ".la");
1432: handle = lt_dlopen(tmp);
1433: if (handle) {
1434: last_error = saved_error;
1435: lt_dlfree(tmp);
1436: return handle;
1437: }
1438: #ifdef LTDL_SHLIB_EXT
1439: /* try "filename.EXT" */
1440: if (strlen(shlib_ext) > 3) {
1441: lt_dlfree(tmp);
1442: tmp = (char*) lt_dlmalloc(len + strlen(shlib_ext) + 1);
1443: if (!tmp) {
1444: last_error = memory_error;
1445: return 0;
1446: }
1447: strcpy(tmp, filename);
1448: } else
1449: tmp[len] = '\0';
1450: strcat(tmp, shlib_ext);
1451: handle = lt_dlopen(tmp);
1452: if (handle) {
1453: last_error = saved_error;
1454: lt_dlfree(tmp);
1455: return handle;
1456: }
1457: #endif
1458: last_error = file_not_found_error;
1459: lt_dlfree(tmp);
1460: return 0;
1461: }
1462:
1463: int
1464: lt_dlclose (handle)
1465: lt_dlhandle handle;
1466: {
1467: lt_dlhandle cur, last;
1468:
1469: /* check whether the handle is valid */
1470: last = cur = handles;
1471: while (cur && handle != cur) {
1472: last = cur;
1473: cur = cur->next;
1474: }
1475: if (!cur) {
1476: last_error = invalid_handle_error;
1477: return 1;
1478: }
1479: handle->usage--;
1480: if (!handle->usage) {
1481: int error;
1482:
1483: if (handle != handles)
1484: last->next = handle->next;
1485: else
1486: handles = handle->next;
1487: error = handle->type->lib_close(handle);
1488: error += unload_deplibs(handle);
1489: if (handle->filename)
1490: lt_dlfree(handle->filename);
1491: if (handle->name)
1492: lt_dlfree(handle->name);
1493: lt_dlfree(handle);
1494: return error;
1495: }
1496: return 0;
1497: }
1498:
1499: lt_ptr_t
1500: lt_dlsym (handle, symbol)
1501: lt_dlhandle handle;
1502: const char *symbol;
1503: {
1504: int lensym;
1505: char lsym[LTDL_SYMBOL_LENGTH];
1506: char *sym;
1507: lt_ptr_t address;
1508:
1509: if (!handle) {
1510: last_error = invalid_handle_error;
1511: return 0;
1512: }
1513: if (!symbol) {
1514: last_error = symbol_error;
1515: return 0;
1516: }
1517: lensym = strlen(symbol);
1518: if (handle->type->sym_prefix)
1519: lensym += strlen(handle->type->sym_prefix);
1520: if (handle->name)
1521: lensym += strlen(handle->name);
1522: if (lensym + LTDL_SYMBOL_OVERHEAD < LTDL_SYMBOL_LENGTH)
1523: sym = lsym;
1524: else
1525: sym = (char*) lt_dlmalloc(lensym + LTDL_SYMBOL_OVERHEAD + 1);
1526: if (!sym) {
1527: last_error = buffer_overflow_error;
1528: return 0;
1529: }
1530: if (handle->name) {
1531: const char *saved_error = last_error;
1532:
1533: /* this is a libtool module */
1534: if (handle->type->sym_prefix) {
1535: strcpy(sym, handle->type->sym_prefix);
1536: strcat(sym, handle->name);
1537: } else
1538: strcpy(sym, handle->name);
1539: strcat(sym, "_LTX_");
1540: strcat(sym, symbol);
1541: /* try "modulename_LTX_symbol" */
1542: address = handle->type->find_sym(handle, sym);
1543: if (address) {
1544: if (sym != lsym)
1545: lt_dlfree(sym);
1546: return address;
1547: }
1548: last_error = saved_error;
1549: }
1550: /* otherwise try "symbol" */
1551: if (handle->type->sym_prefix) {
1552: strcpy(sym, handle->type->sym_prefix);
1553: strcat(sym, symbol);
1554: } else
1555: strcpy(sym, symbol);
1556: address = handle->type->find_sym(handle, sym);
1557: if (sym != lsym)
1558: lt_dlfree(sym);
1559: return address;
1560: }
1561:
1562: const char *
1563: lt_dlerror LTDL_PARAMS((void))
1564: {
1565: const char *error = last_error;
1566:
1567: last_error = 0;
1568: return error;
1569: }
1570:
1571: int
1572: lt_dladdsearchdir (search_dir)
1573: const char *search_dir;
1574: {
1575: if (!search_dir || !strlen(search_dir))
1576: return 0;
1577: if (!user_search_path) {
1578: user_search_path = strdup(search_dir);
1579: if (!user_search_path) {
1580: last_error = memory_error;
1581: return 1;
1582: }
1583: } else {
1584: char *new_search_path = (char*)
1585: lt_dlmalloc(strlen(user_search_path) +
1586: strlen(search_dir) + 2); /* ':' + '\0' == 2 */
1587: if (!new_search_path) {
1588: last_error = memory_error;
1589: return 1;
1590: }
1591: strcpy(new_search_path, user_search_path);
1592: strcat(new_search_path, ":");
1593: strcat(new_search_path, search_dir);
1594: lt_dlfree(user_search_path);
1595: user_search_path = new_search_path;
1596: }
1597: return 0;
1598: }
1599:
1600: int
1601: lt_dlsetsearchpath (search_path)
1602: const char *search_path;
1603: {
1604: if (user_search_path)
1605: lt_dlfree(user_search_path);
1606: user_search_path = 0; /* reset the search path */
1607: if (!search_path || !strlen(search_path))
1608: return 0;
1609: user_search_path = strdup(search_path);
1610: if (!user_search_path)
1611: return 1;
1612: return 0;
1613: }
1614:
1615: const char *
1616: lt_dlgetsearchpath LTDL_PARAMS((void))
1617: {
1618: return user_search_path;
1619: }