Annotation of sql/pgsql/libltdl/loaders/preopen.c, revision 1.1
1.1 ! moko 1: /* loader-preopen.c -- emulate dynamic linking using preloaded_symbols
! 2:
! 3: Copyright (C) 1998, 1999, 2000, 2004, 2006,
! 4: 2007, 2008 Free Software 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:
! 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.
! 14:
! 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.
! 19:
! 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.
! 24:
! 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.
! 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:
! 41: LT_BEGIN_C_DECLS
! 42: LT_SCOPE lt_dlvtable *get_vtable (lt_user_data loader_data);
! 43: LT_END_C_DECLS
! 44:
! 45:
! 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,
! 51: lt_dladvise advise);
! 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);
! 55:
! 56: static 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. */
! 61: lt_dlvtable *
! 62: get_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. */
! 97: typedef struct symlist_chain
! 98: {
! 99: struct symlist_chain *next;
! 100: const lt_dlsymlist *symlist;
! 101: } symlist_chain;
! 102:
! 103:
! 104: static int add_symlist (const lt_dlsymlist *symlist);
! 105: static int free_symlists (void);
! 106:
! 107: /* The start of the symbol lists chain. */
! 108: static symlist_chain *preloaded_symlists = 0;
! 109:
! 110: /* A symbol list preloaded before lt_init() was called. */
! 111: static const lt_dlsymlist *default_preloaded_symbols = 0;
! 112:
! 113:
! 114: /* A function called through the vtable to initialise this loader. */
! 115: static int
! 116: vl_init (lt_user_data LT__UNUSED loader_data)
! 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. */
! 132: static int
! 133: vl_exit (lt_user_data LT__UNUSED loader_data)
! 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. */
! 144: static lt_module
! 145: vm_open (lt_user_data LT__UNUSED loader_data, const char *filename,
! 146: lt_dladvise LT__UNUSED advise)
! 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. */
! 197: static int
! 198: vm_close (lt_user_data LT__UNUSED loader_data, lt_module LT__UNUSED module)
! 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. */
! 208: static void *
! 209: vm_sym (lt_user_data LT__UNUSED loader_data, lt_module module, const char *name)
! 210: {
! 211: lt_dlsymlist *symbol = (lt_dlsymlist*) module;
! 212:
! 213: symbol +=2; /* Skip header (originator then libname). */
! 214:
! 215: while (symbol->name)
! 216: {
! 217: if (streq (symbol->name, name))
! 218: {
! 219: return symbol->address;
! 220: }
! 221:
! 222: ++symbol;
! 223: }
! 224:
! 225: LT__SETERROR (SYMBOL_NOT_FOUND);
! 226:
! 227: return 0;
! 228: }
! 229:
! 230:
! 231:
! 232: /* --- HELPER FUNCTIONS --- */
! 233:
! 234:
! 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. */
! 237: static int
! 238: free_symlists (void)
! 239: {
! 240: symlist_chain *lists;
! 241:
! 242: lists = preloaded_symlists;
! 243: while (lists)
! 244: {
! 245: symlist_chain *next = lists->next;
! 246: FREE (lists);
! 247: lists = next;
! 248: }
! 249: preloaded_symlists = 0;
! 250:
! 251: return 0;
! 252: }
! 253:
! 254: /* Add a new symbol list to the global chain. */
! 255: static int
! 256: add_symlist (const lt_dlsymlist *symlist)
! 257: {
! 258: symlist_chain *lists;
! 259: int errors = 0;
! 260:
! 261: /* Search for duplicate entries: */
! 262: for (lists = preloaded_symlists;
! 263: lists && lists->symlist != symlist; lists = lists->next)
! 264: /*NOWORK*/;
! 265:
! 266: /* Don't add the same list twice: */
! 267: if (!lists)
! 268: {
! 269: symlist_chain *tmp = (symlist_chain *) lt__zalloc (sizeof *tmp);
! 270:
! 271: if (tmp)
! 272: {
! 273: tmp->symlist = symlist;
! 274: tmp->next = preloaded_symlists;
! 275: preloaded_symlists = tmp;
! 276: }
! 277: else
! 278: {
! 279: ++errors;
! 280: }
! 281: }
! 282:
! 283: return errors;
! 284: }
! 285:
! 286:
! 287:
! 288: /* --- PRELOADING API CALL IMPLEMENTATIONS --- */
! 289:
! 290:
! 291: /* Save a default symbol list for later. */
! 292: int
! 293: lt_dlpreload_default (const lt_dlsymlist *preloaded)
! 294: {
! 295: default_preloaded_symbols = preloaded;
! 296: return 0;
! 297: }
! 298:
! 299:
! 300: /* Add a symbol list to the global chain, or with a NULL argument,
! 301: revert to just the default list. */
! 302: int
! 303: lt_dlpreload (const lt_dlsymlist *preloaded)
! 304: {
! 305: int errors = 0;
! 306:
! 307: if (preloaded)
! 308: {
! 309: errors = add_symlist (preloaded);
! 310: }
! 311: else
! 312: {
! 313: free_symlists();
! 314:
! 315: if (default_preloaded_symbols)
! 316: {
! 317: errors = lt_dlpreload (default_preloaded_symbols);
! 318: }
! 319: }
! 320:
! 321: return errors;
! 322: }
! 323:
! 324:
! 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. */
! 328: int
! 329: lt_dlpreload_open (const char *originator, lt_dlpreload_callback_func *func)
! 330: {
! 331: symlist_chain *list;
! 332: int errors = 0;
! 333: int found = 0;
! 334:
! 335: /* For each symlist in the chain... */
! 336: for (list = preloaded_symlists; list; list = list->next)
! 337: {
! 338: /* ...that was preloaded by the requesting ORIGINATOR... */
! 339: if ((originator && streq (list->symlist->name, originator))
! 340: || (!originator && streq (list->symlist->name, "@PROGRAM@")))
! 341: {
! 342: const lt_dlsymlist *symbol;
! 343: unsigned int idx = 0;
! 344:
! 345: ++found;
! 346:
! 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)
! 350: {
! 351: if ((symbol->address == 0)
! 352: && (strneq (symbol->name, "@PROGRAM@")))
! 353: {
! 354: lt_dlhandle handle = lt_dlopen (symbol->name);
! 355: if (handle == 0)
! 356: {
! 357: ++errors;
! 358: }
! 359: else
! 360: {
! 361: errors += (*func) (handle);
! 362: }
! 363: }
! 364: }
! 365: }
! 366: }
! 367:
! 368: if (!found)
! 369: {
! 370: LT__SETERROR(CANNOT_OPEN);
! 371: ++errors;
! 372: }
! 373:
! 374: return errors;
! 375: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to preopen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / sql / pgsql / libltdl / loaders