1 /* loader-preopen.c -- emulate dynamic linking using preloaded_symbols
3 Copyright (C) 1998, 1999, 2000, 2004, 2006,
4 2007, 2008 Free Software Foundation, Inc.
5 Written by Thomas Tanner, 1998
7 NOTE: The canonical source of this file is maintained with the
8 GNU Libtool package. Report bugs to bug-libtool@gnu.org.
10 GNU Libltdl is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 2 of the License, or (at your option) any later version.
15 As a special exception to the GNU Lesser General Public License,
16 if you distribute this file as part of a program or library that
17 is built using GNU Libtool, you may include this file under the
18 same distribution terms that you use for the rest of that program.
20 GNU Libltdl is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU Lesser General Public License for more details.
25 You should have received a copy of the GNU Lesser General Public
26 License along with GNU Libltdl; see the file COPYING.LIB. If not, a
27 copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
28 or obtained by writing to the Free Software Foundation, Inc.,
29 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
32 #include "lt__private.h"
33 #include "lt_dlloader.h"
35 /* Use the preprocessor to rename non-static symbols to avoid namespace
36 collisions when the loader code is statically linked into libltdl.
37 Use the "<module_name>_LTX_" prefix so that the symbol addresses can
38 be fetched from the preloaded symbol list by lt_dlsym(): */
39 #define get_vtable preopen_LTX_get_vtable
42 LT_SCOPE lt_dlvtable
*get_vtable (lt_user_data loader_data
);
46 /* Boilerplate code to set up the vtable for hooking this loader into
47 libltdl's loader list: */
48 static int vl_init (lt_user_data loader_data
);
49 static int vl_exit (lt_user_data loader_data
);
50 static lt_module
vm_open (lt_user_data loader_data
, const char *filename
,
52 static int vm_close (lt_user_data loader_data
, lt_module module
);
53 static void * vm_sym (lt_user_data loader_data
, lt_module module
,
54 const char *symbolname
);
56 static lt_dlvtable
*vtable
= 0;
58 /* Return the vtable for this loader, only the name and sym_prefix
59 attributes (plus the virtual function implementations, obviously)
60 change between loaders. */
62 get_vtable (lt_user_data loader_data
)
66 vtable
= (lt_dlvtable
*) lt__zalloc (sizeof *vtable
);
69 if (vtable
&& !vtable
->name
)
71 vtable
->name
= "lt_preopen";
72 vtable
->sym_prefix
= 0;
73 vtable
->module_open
= vm_open
;
74 vtable
->module_close
= vm_close
;
75 vtable
->find_sym
= vm_sym
;
76 vtable
->dlloader_init
= vl_init
;
77 vtable
->dlloader_exit
= vl_exit
;
78 vtable
->dlloader_data
= loader_data
;
79 vtable
->priority
= LT_DLLOADER_PREPEND
;
82 if (vtable
&& (vtable
->dlloader_data
!= loader_data
))
84 LT__SETERROR (INIT_LOADER
);
93 /* --- IMPLEMENTATION --- */
96 /* Wrapper type to chain together symbol lists of various origins. */
97 typedef struct symlist_chain
99 struct symlist_chain
*next
;
100 const lt_dlsymlist
*symlist
;
104 static int add_symlist (const lt_dlsymlist
*symlist
);
105 static int free_symlists (void);
107 /* The start of the symbol lists chain. */
108 static symlist_chain
*preloaded_symlists
= 0;
110 /* A symbol list preloaded before lt_init() was called. */
111 static const lt_dlsymlist
*default_preloaded_symbols
= 0;
114 /* A function called through the vtable to initialise this loader. */
116 vl_init (lt_user_data LT__UNUSED loader_data
)
120 preloaded_symlists
= 0;
121 if (default_preloaded_symbols
)
123 errors
= lt_dlpreload (default_preloaded_symbols
);
130 /* A function called through the vtable when this loader is no
131 longer needed by the application. */
133 vl_exit (lt_user_data LT__UNUSED loader_data
)
141 /* A function called through the vtable to open a module with this
142 loader. Returns an opaque representation of the newly opened
143 module for processing with this loader's other vtable functions. */
145 vm_open (lt_user_data LT__UNUSED loader_data
, const char *filename
,
146 lt_dladvise LT__UNUSED advise
)
148 symlist_chain
*lists
;
149 lt_module module
= 0;
151 if (!preloaded_symlists
)
153 LT__SETERROR (NO_SYMBOLS
);
157 /* Can't use NULL as the reflective symbol header, as NULL is
158 used to mark the end of the entire symbol list. Self-dlpreopened
159 symbols follow this magic number, chosen to be an unlikely
160 clash with a real module name. */
163 filename
= "@PROGRAM@";
166 for (lists
= preloaded_symlists
; lists
; lists
= lists
->next
)
168 const lt_dlsymlist
*symbol
;
169 for (symbol
= lists
->symlist
; symbol
->name
; ++symbol
)
171 if (!symbol
->address
&& streq (symbol
->name
, filename
))
173 /* If the next symbol's name and address is 0, it means
174 the module just contains the originator and no symbols.
175 In this case we pretend that we never saw the module and
176 hope that some other loader will be able to load the module
177 and have access to its symbols */
178 const lt_dlsymlist
*next_symbol
= symbol
+1;
179 if (next_symbol
->address
&& next_symbol
->name
)
181 module
= (lt_module
) lists
->symlist
;
188 LT__SETERROR (FILE_NOT_FOUND
);
195 /* A function called through the vtable when a particular module
196 should be unloaded. */
198 vm_close (lt_user_data LT__UNUSED loader_data
, lt_module LT__UNUSED module
)
200 /* Just to silence gcc -Wall */
206 /* A function called through the vtable to get the address of
207 a symbol loaded from a particular module. */
209 vm_sym (lt_user_data LT__UNUSED loader_data
, lt_module module
, const char *name
)
211 lt_dlsymlist
*symbol
= (lt_dlsymlist
*) module
;
213 symbol
+=2; /* Skip header (originator then libname). */
217 if (streq (symbol
->name
, name
))
219 return symbol
->address
;
225 LT__SETERROR (SYMBOL_NOT_FOUND
);
232 /* --- HELPER FUNCTIONS --- */
235 /* The symbol lists themselves are not allocated from the heap, but
236 we can unhook them and free up the chain of links between them. */
240 symlist_chain
*lists
;
242 lists
= preloaded_symlists
;
245 symlist_chain
*next
= lists
->next
;
249 preloaded_symlists
= 0;
254 /* Add a new symbol list to the global chain. */
256 add_symlist (const lt_dlsymlist
*symlist
)
258 symlist_chain
*lists
;
261 /* Search for duplicate entries: */
262 for (lists
= preloaded_symlists
;
263 lists
&& lists
->symlist
!= symlist
; lists
= lists
->next
)
266 /* Don't add the same list twice: */
269 symlist_chain
*tmp
= (symlist_chain
*) lt__zalloc (sizeof *tmp
);
273 tmp
->symlist
= symlist
;
274 tmp
->next
= preloaded_symlists
;
275 preloaded_symlists
= tmp
;
288 /* --- PRELOADING API CALL IMPLEMENTATIONS --- */
291 /* Save a default symbol list for later. */
293 lt_dlpreload_default (const lt_dlsymlist
*preloaded
)
295 default_preloaded_symbols
= preloaded
;
300 /* Add a symbol list to the global chain, or with a NULL argument,
301 revert to just the default list. */
303 lt_dlpreload (const lt_dlsymlist
*preloaded
)
309 errors
= add_symlist (preloaded
);
315 if (default_preloaded_symbols
)
317 errors
= lt_dlpreload (default_preloaded_symbols
);
325 /* Open all the preloaded modules from the named originator, executing
326 a callback for each one. If ORIGINATOR is NULL, then call FUNC for
327 each preloaded module from the program itself. */
329 lt_dlpreload_open (const char *originator
, lt_dlpreload_callback_func
*func
)
335 /* For each symlist in the chain... */
336 for (list
= preloaded_symlists
; list
; list
= list
->next
)
338 /* ...that was preloaded by the requesting ORIGINATOR... */
339 if ((originator
&& streq (list
->symlist
->name
, originator
))
340 || (!originator
&& streq (list
->symlist
->name
, "@PROGRAM@")))
342 const lt_dlsymlist
*symbol
;
343 unsigned int idx
= 0;
347 /* ...load the symbols per source compilation unit:
348 (we preincrement the index to skip over the originator entry) */
349 while ((symbol
= &list
->symlist
[++idx
])->name
!= 0)
351 if ((symbol
->address
== 0)
352 && (strneq (symbol
->name
, "@PROGRAM@")))
354 lt_dlhandle handle
= lt_dlopen (symbol
->name
);
361 errors
+= (*func
) (handle
);
370 LT__SETERROR(CANNOT_OPEN
);