1/* loader-preopen.c -- emulate dynamic linking using preloaded_symbols
2
3 Copyright (C) 1998-2000, 2004, 2006-2008, 2011-2015 Free Software
4 Foundation, Inc.
5 Written by Thomas Tanner, 1998
6
7 NOTE: The canonical source of this file is maintained with the
8 GNU Libtool package. Report bugs to bug-libtool@gnu.org.
9
10GNU Libltdl is free software; you can redistribute it and/or
11modify it under the terms of the GNU Lesser General Public
12License as published by the Free Software Foundation; either
13version 2 of the License, or (at your option) any later version.
14
15As a special exception to the GNU Lesser General Public License,
16if you distribute this file as part of a program or library that
17is built using GNU Libtool, you may include this file under the
18same distribution terms that you use for the rest of that program.
19
20GNU Libltdl is distributed in the hope that it will be useful,
21but WITHOUT ANY WARRANTY; without even the implied warranty of
22MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23GNU Lesser General Public License for more details.
24
25You should have received a copy of the GNU Lesser General Public
26License along with GNU Libltdl; see the file COPYING.LIB. If not, a
27copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
28or obtained by writing to the Free Software Foundation, Inc.,
2951 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30*/
31
32#include "lt__private.h"
33#include "lt_dlloader.h"
34
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
40
41LT_BEGIN_C_DECLS
42LT_SCOPE lt_dlvtable *get_vtable (lt_user_data loader_data);
43LT_END_C_DECLS
44
45
46/* Boilerplate code to set up the vtable for hooking this loader into
47 libltdl's loader list: */
48static int vl_init (lt_user_data loader_data);
49static int vl_exit (lt_user_data loader_data);
50static lt_module vm_open (lt_user_data loader_data, const char *filename,
51 lt_dladvise advise);
52static int vm_close (lt_user_data loader_data, lt_module module);
53static void * vm_sym (lt_user_data loader_data, lt_module module,
54 const char *symbolname);
55
56static lt_dlvtable *vtable = 0;
57
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. */
61lt_dlvtable *
62get_vtable (lt_user_data loader_data)
63{
64 if (!vtable)
65 {
66 vtable = (lt_dlvtable *) lt__zalloc (sizeof *vtable);
67 }
68
69 if (vtable && !vtable->name)
70 {
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;
80 }
81
82 if (vtable && (vtable->dlloader_data != loader_data))
83 {
84 LT__SETERROR (INIT_LOADER);
85 return 0;
86 }
87
88 return vtable;
89}
90
91
92
93/* --- IMPLEMENTATION --- */
94
95
96/* Wrapper type to chain together symbol lists of various origins. */
97typedef struct symlist_chain
98{
99 struct symlist_chain *next;
100 const lt_dlsymlist *symlist;
101} symlist_chain;
102
103
104static int add_symlist (const lt_dlsymlist *symlist);
105static int free_symlists (void);
106
107/* The start of the symbol lists chain. */
108static symlist_chain *preloaded_symlists = 0;
109
110/* A symbol list preloaded before lt_init() was called. */
111static const lt_dlsymlist *default_preloaded_symbols = 0;
112
113
114/* A function called through the vtable to initialise this loader. */
115static int
116vl_init (lt_user_data loader_data LT__UNUSED)
117{
118 int errors = 0;
119
120 preloaded_symlists = 0;
121 if (default_preloaded_symbols)
122 {
123 errors = lt_dlpreload (default_preloaded_symbols);
124 }
125
126 return errors;
127}
128
129
130/* A function called through the vtable when this loader is no
131 longer needed by the application. */
132static int
133vl_exit (lt_user_data loader_data LT__UNUSED)
134{
135 vtable = NULL;
136 free_symlists ();
137 return 0;
138}
139
140
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. */
144static lt_module
145vm_open (lt_user_data loader_data LT__UNUSED, const char *filename,
146 lt_dladvise advise LT__UNUSED)
147{
148 symlist_chain *lists;
149 lt_module module = 0;
150
151 if (!preloaded_symlists)
152 {
153 LT__SETERROR (NO_SYMBOLS);
154 goto done;
155 }
156
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. */
161 if (!filename)
162 {
163 filename = "@PROGRAM@";
164 }
165
166 for (lists = preloaded_symlists; lists; lists = lists->next)
167 {
168 const lt_dlsymlist *symbol;
169 for (symbol= lists->symlist; symbol->name; ++symbol)
170 {
171 if (!symbol->address && STREQ (symbol->name, filename))
172 {
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)
180 {
181 module = (lt_module) lists->symlist;
182 goto done;
183 }
184 }
185 }
186 }
187
188 LT__SETERROR (FILE_NOT_FOUND);
189
190 done:
191 return module;
192}
193
194
195/* A function called through the vtable when a particular module
196 should be unloaded. */
197static int
198vm_close (lt_user_data loader_data LT__UNUSED, lt_module module LT__UNUSED)
199{
200 /* Just to silence gcc -Wall */
201 module = 0;
202 return 0;
203}
204
205
206/* A function called through the vtable to get the address of
207 a symbol loaded from a particular module. */
208static void *
209vm_sym (lt_user_data loader_data LT__UNUSED, lt_module module, const char *name)
210{
211 lt_dlsymlist *symbol = (lt_dlsymlist*) module;
212
213 if (symbol[1].name && STREQ (symbol[1].name, "@INIT@"))
214 {
215 symbol++; /* Skip optional init entry. */
216 }
217
218 symbol +=2; /* Skip header (originator then libname). */
219
220 while (symbol->name)
221 {
222 if (STREQ (symbol->name, name))
223 {
224 return symbol->address;
225 }
226
227 ++symbol;
228 }
229
230 LT__SETERROR (SYMBOL_NOT_FOUND);
231
232 return 0;
233}
234
235
236
237/* --- HELPER FUNCTIONS --- */
238
239
240/* The symbol lists themselves are not allocated from the heap, but
241 we can unhook them and free up the chain of links between them. */
242static int
243free_symlists (void)
244{
245 symlist_chain *lists;
246
247 lists = preloaded_symlists;
248 while (lists)
249 {
250 symlist_chain *next = lists->next;
251 FREE (lists);
252 lists = next;
253 }
254 preloaded_symlists = 0;
255
256 return 0;
257}
258
259/* Add a new symbol list to the global chain. */
260static int
261add_symlist (const lt_dlsymlist *symlist)
262{
263 symlist_chain *lists;
264 int errors = 0;
265
266 /* Search for duplicate entries: */
267 for (lists = preloaded_symlists;
268 lists && lists->symlist != symlist; lists = lists->next)
269 /*NOWORK*/;
270
271 /* Don't add the same list twice: */
272 if (!lists)
273 {
274 symlist_chain *tmp = (symlist_chain *) lt__zalloc (sizeof *tmp);
275
276 if (tmp)
277 {
278 tmp->symlist = symlist;
279 tmp->next = preloaded_symlists;
280 preloaded_symlists = tmp;
281
282 if (symlist[1].name && STREQ (symlist[1].name, "@INIT@"))
283 {
284 void (*init_symlist)(void);
285 *(void **)(&init_symlist) = symlist[1].address;
286 (*init_symlist)();
287 }
288 }
289 else
290 {
291 ++errors;
292 }
293 }
294
295 return errors;
296}
297
298
299
300/* --- PRELOADING API CALL IMPLEMENTATIONS --- */
301
302
303/* Save a default symbol list for later. */
304int
305lt_dlpreload_default (const lt_dlsymlist *preloaded)
306{
307 default_preloaded_symbols = preloaded;
308 return 0;
309}
310
311
312/* Add a symbol list to the global chain, or with a NULL argument,
313 revert to just the default list. */
314int
315lt_dlpreload (const lt_dlsymlist *preloaded)
316{
317 int errors = 0;
318
319 if (preloaded)
320 {
321 errors = add_symlist (preloaded);
322 }
323 else
324 {
325 free_symlists();
326
327 if (default_preloaded_symbols)
328 {
329 errors = lt_dlpreload (default_preloaded_symbols);
330 }
331 }
332
333 return errors;
334}
335
336
337/* Open all the preloaded modules from the named originator, executing
338 a callback for each one. If ORIGINATOR is NULL, then call FUNC for
339 each preloaded module from the program itself. */
340int
341lt_dlpreload_open (const char *originator, lt_dlpreload_callback_func *func)
342{
343 symlist_chain *list;
344 int errors = 0;
345 int found = 0;
346
347 /* For each symlist in the chain... */
348 for (list = preloaded_symlists; list; list = list->next)
349 {
350 /* ...that was preloaded by the requesting ORIGINATOR... */
351 if ((originator && STREQ (list->symlist->name, originator))
352 || (!originator && STREQ (list->symlist->name, "@PROGRAM@")))
353 {
354 const lt_dlsymlist *symbol;
355 unsigned int idx = 0;
356
357 ++found;
358
359 /* ...load the symbols per source compilation unit:
360 (we preincrement the index to skip over the originator entry) */
361 while ((symbol = &list->symlist[++idx])->name != 0)
362 {
363 if ((symbol->address == 0)
364 && (STRNEQ (symbol->name, "@PROGRAM@")))
365 {
366 lt_dlhandle handle = lt_dlopen (symbol->name);
367 if (handle == 0)
368 {
369 ++errors;
370 }
371 else
372 {
373 errors += (*func) (handle);
374 }
375 }
376 }
377 }
378 }
379
380 if (!found)
381 {
382 LT__SETERROR(CANNOT_OPEN);
383 ++errors;
384 }
385
386 return errors;
387}
388