libltdl/loaders/dyld.c

/* */
This source file includes following definitions.
get_vtable
vl_exit
vl_init
vm_open
vm_close
vm_sym
dylderror
lt__nsmodule_get_header
lt__header_get_instnam
lt__match_loadedlib
lt__linkedlib_symbol
   1 /* loader-dyld.c -- dynamic linking on darwin and OS X
   2 
   3    Copyright (C) 1998-2000, 2004, 2006-2008, 2011-2015 Free Software
   4    Foundation, Inc.
   5    Written by Peter O'Gorman, 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      dyld_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__zalloc (sizeof *vtable);
  67     }
  68 
  69   if (vtable && !vtable->name)
  70     {
  71       vtable->name              = "lt_dyld";
  72       vtable->sym_prefix        = "_";
  73       vtable->dlloader_init     = vl_init;
  74       vtable->module_open       = vm_open;
  75       vtable->module_close      = vm_close;
  76       vtable->find_sym          = vm_sym;
  77       vtable->dlloader_exit     = vl_exit;
  78       vtable->dlloader_data     = loader_data;
  79       vtable->priority          = LT_DLLOADER_APPEND;
  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 #if defined HAVE_MACH_O_DYLD_H
  97 #  if !defined __APPLE_CC__ && !defined __MWERKS__ && !defined __private_extern__
  98   /* Is this correct? Does it still function properly? */
  99 #    define __private_extern__ extern
 100 #  endif
 101 #  include <mach-o/dyld.h>
 102 #endif
 103 
 104 #include <mach-o/getsect.h>
 105 
 106 /* We have to put some stuff here that isn't in older dyld.h files */
 107 #if !defined ENUM_DYLD_BOOL
 108 # define ENUM_DYLD_BOOL
 109 # undef FALSE
 110 # undef TRUE
 111  enum DYLD_BOOL {
 112     FALSE,
 113     TRUE
 114  };
 115 #endif
 116 #if !defined LC_REQ_DYLD
 117 # define LC_REQ_DYLD 0x80000000
 118 #endif
 119 #if !defined LC_LOAD_WEAK_DYLIB
 120 # define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD)
 121 #endif
 122 
 123 #if !defined NSADDIMAGE_OPTION_NONE
 124 #  define NSADDIMAGE_OPTION_NONE                          0x0
 125 #endif
 126 #if !defined NSADDIMAGE_OPTION_RETURN_ON_ERROR
 127 #  define NSADDIMAGE_OPTION_RETURN_ON_ERROR               0x1
 128 #endif
 129 #if !defined NSADDIMAGE_OPTION_WITH_SEARCHING
 130 #  define NSADDIMAGE_OPTION_WITH_SEARCHING                0x2
 131 #endif
 132 #if !defined NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
 133 #  define NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED         0x4
 134 #endif
 135 #if !defined NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME
 136 #  define NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME 0x8
 137 #endif
 138 
 139 #if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND
 140 #  define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND               0x0
 141 #endif
 142 #if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW
 143 #  define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW           0x1
 144 #endif
 145 #if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY
 146 #  define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY         0x2
 147 #endif
 148 #if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR
 149 #  define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR    0x4
 150 #endif
 151 
 152 #define LT__SYMLOOKUP_OPTS      (NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW \
 153                                 | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR)
 154 
 155 #if defined __BIG_ENDIAN__
 156 #  define LT__MAGIC     MH_MAGIC
 157 #else
 158 #  define LT__MAGIC     MH_CIGAM
 159 #endif
 160 
 161 #define DYLD__SETMYERROR(errmsg)    LT__SETERRORSTR (dylderror (errmsg))
 162 #define DYLD__SETERROR(errcode)     DYLD__SETMYERROR (LT__STRERROR (errcode))
 163 
 164 typedef struct mach_header mach_header;
 165 typedef struct dylib_command dylib_command;
 166 
 167 static const char *dylderror (const char *errmsg);
 168 static const mach_header *lt__nsmodule_get_header (NSModule module);
 169 static const char *lt__header_get_instnam (const mach_header *mh);
 170 static const mach_header *lt__match_loadedlib (const char *name);
 171 static NSSymbol lt__linkedlib_symbol (const char *symname, const mach_header *mh);
 172 
 173 static const mach_header *(*lt__addimage)       (const char *image_name,
 174                                                  unsigned long options) = 0;
 175 static NSSymbol (*lt__image_symbol)             (const mach_header *image,
 176                                                  const char *symbolName,
 177                                                  unsigned long options) = 0;
 178 static enum DYLD_BOOL (*lt__image_symbol_p)     (const mach_header *image,
 179                                                  const char *symbolName) = 0;
 180 static enum DYLD_BOOL (*lt__module_export)      (NSModule module) = 0;
 181 
 182 static int dyld_cannot_close                              = 0;
 183 
 184 
 185 /* A function called through the vtable when this loader is no
 186    longer needed by the application.  */
 187 static int
 188 vl_exit (lt_user_data loader_data LT__UNUSED)
     /*  */
 189 {
 190   vtable = NULL;
 191   return 0;
 192 }
 193 
 194 /* A function called through the vtable to initialise this loader.  */
 195 static int
 196 vl_init (lt_user_data loader_data)
     /*  */
 197 {
 198   int errors = 0;
 199 
 200   if (! dyld_cannot_close)
 201     {
 202       if (!_dyld_present ())
 203         {
 204           ++errors;
 205         }
 206       else
 207         {
 208           (void) _dyld_func_lookup ("__dyld_NSAddImage",
 209                                     (unsigned long*) &lt__addimage);
 210           (void) _dyld_func_lookup ("__dyld_NSLookupSymbolInImage",
 211                                     (unsigned long*)&lt__image_symbol);
 212           (void) _dyld_func_lookup ("__dyld_NSIsSymbolNameDefinedInImage",
 213                                     (unsigned long*) &lt__image_symbol_p);
 214           (void) _dyld_func_lookup ("__dyld_NSMakePrivateModulePublic",
 215                                     (unsigned long*) &lt__module_export);
 216           dyld_cannot_close = lt_dladderror ("can't close a dylib");
 217         }
 218     }
 219 
 220   return errors;
 221 }
 222 
 223 
 224 /* A function called through the vtable to open a module with this
 225    loader.  Returns an opaque representation of the newly opened
 226    module for processing with this loader's other vtable functions.  */
 227 static lt_module
 228 vm_open (lt_user_data loader_data, const char *filename,
     /*  */
 229          lt_dladvise advise LT__UNUSED)
 230 {
 231   lt_module module = 0;
 232   NSObjectFileImage ofi = 0;
 233 
 234   if (!filename)
 235     {
 236       return (lt_module) -1;
 237     }
 238 
 239   switch (NSCreateObjectFileImageFromFile (filename, &ofi))
 240     {
 241     case NSObjectFileImageSuccess:
 242       module = NSLinkModule (ofi, filename, NSLINKMODULE_OPTION_RETURN_ON_ERROR
 243                                             | NSLINKMODULE_OPTION_PRIVATE
 244                                             | NSLINKMODULE_OPTION_BINDNOW);
 245       NSDestroyObjectFileImage (ofi);
 246 
 247       if (module)
 248         {
 249           lt__module_export (module);
 250         }
 251       break;
 252 
 253     case NSObjectFileImageInappropriateFile:
 254       if (lt__image_symbol_p && lt__image_symbol)
 255         {
 256           module = (lt_module) lt__addimage(filename,
 257                                             NSADDIMAGE_OPTION_RETURN_ON_ERROR);
 258         }
 259       break;
 260 
 261     case NSObjectFileImageFailure:
 262     case NSObjectFileImageArch:
 263     case NSObjectFileImageFormat:
 264     case NSObjectFileImageAccess:
 265       /*NOWORK*/
 266       break;
 267     }
 268 
 269   if (!module)
 270     {
 271       DYLD__SETERROR (CANNOT_OPEN);
 272     }
 273 
 274   return module;
 275 }
 276 
 277 
 278 /* A function called through the vtable when a particular module
 279    should be unloaded.  */
 280 static int
 281 vm_close (lt_user_data loader_data, lt_module module)
     /*  */
 282 {
 283   int errors = 0;
 284 
 285   if (module != (lt_module) -1)
 286     {
 287       const mach_header *mh = (const mach_header *) module;
 288       int flags = 0;
 289       if (mh->magic == LT__MAGIC)
 290         {
 291           lt_dlseterror (dyld_cannot_close);
 292           ++errors;
 293         }
 294       else
 295         {
 296           /* Currently, if a module contains c++ static destructors and it
 297              is unloaded, we get a segfault in atexit(), due to compiler and
 298              dynamic loader differences of opinion, this works around that.  */
 299           if ((const struct section *) NULL !=
 300               getsectbynamefromheader (lt__nsmodule_get_header (module),
 301                                        "__DATA", "__mod_term_func"))
 302             {
 303               flags |= NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED;
 304             }
 305 #if defined __ppc__
 306           flags |= NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES;
 307 #endif
 308           if (!NSUnLinkModule (module, flags))
 309             {
 310               DYLD__SETERROR (CANNOT_CLOSE);
 311               ++errors;
 312             }
 313         }
 314     }
 315 
 316   return errors;
 317 }
 318 
 319 /* A function called through the vtable to get the address of
 320    a symbol loaded from a particular module.  */
 321 static void *
 322 vm_sym (lt_user_data loader_data, lt_module module, const char *name)
     /*  */
 323 {
 324   NSSymbol *nssym = 0;
 325   const mach_header *mh = (const mach_header *) module;
 326   char saveError[256] = "Symbol not found";
 327 
 328   if (module == (lt_module) -1)
 329     {
 330       void *address, *unused;
 331       _dyld_lookup_and_bind (name, (unsigned long*) &address, &unused);
 332       return address;
 333     }
 334 
 335   if (mh->magic == LT__MAGIC)
 336     {
 337       if (lt__image_symbol_p && lt__image_symbol)
 338         {
 339           if (lt__image_symbol_p (mh, name))
 340             {
 341               nssym = lt__image_symbol (mh, name, LT__SYMLOOKUP_OPTS);
 342             }
 343         }
 344 
 345     }
 346   else
 347     {
 348       nssym = NSLookupSymbolInModule (module, name);
 349     }
 350 
 351   if (!nssym)
 352     {
 353       strlcpy (saveError, dylderror (LT__STRERROR (SYMBOL_NOT_FOUND)), 255);
 354       saveError[255] = 0;
 355       if (!mh)
 356         {
 357           mh = (mach_header *)lt__nsmodule_get_header (module);
 358         }
 359       nssym = lt__linkedlib_symbol (name, mh);
 360     }
 361 
 362   if (!nssym)
 363     {
 364       LT__SETERRORSTR (saveError);
 365     }
 366 
 367   return nssym ? NSAddressOfSymbol (nssym) : 0;
 368 }
 369 
 370 
 371 
 372 
 373 /* --- HELPER FUNCTIONS --- */
 374 
 375 
 376 /* Return the dyld error string, or the passed in error string if none. */
 377 static const char *
 378 dylderror (const char *errmsg)
     /*  */
 379 {
 380   NSLinkEditErrors ler;
 381   int lerno;
 382   const char *file;
 383   const char *errstr;
 384 
 385   NSLinkEditError (&ler, &lerno, &file, &errstr);
 386 
 387   if (! (errstr && *errstr))
 388     {
 389       errstr = errmsg;
 390     }
 391 
 392   return errstr;
 393 }
 394 
 395 /* There should probably be an apple dyld api for this. */
 396 static const mach_header *
 397 lt__nsmodule_get_header (NSModule module)
     /*  */
 398 {
 399   int i = _dyld_image_count();
 400   const char *modname = NSNameOfModule (module);
 401   const mach_header *mh = 0;
 402 
 403   if (!modname)
 404     return NULL;
 405 
 406   while (i > 0)
 407     {
 408       --i;
 409       if (strneq (_dyld_get_image_name (i), modname))
 410         {
 411           mh = _dyld_get_image_header (i);
 412           break;
 413         }
 414     }
 415 
 416   return mh;
 417 }
 418 
 419 /* NSAddImage is also used to get the loaded image, but it only works if
 420    the lib is installed, for uninstalled libs we need to check the
 421    install_names against each other.  Note that this is still broken if
 422    DYLD_IMAGE_SUFFIX is set and a different lib was loaded as a result.  */
 423 static const char *
 424 lt__header_get_instnam (const mach_header *mh)
     /*  */
 425 {
 426   unsigned long offset = sizeof(mach_header);
 427   const char* result   = 0;
 428   int j;
 429 
 430   for (j = 0; j < mh->ncmds; j++)
 431     {
 432       struct load_command *lc;
 433 
 434       lc = (struct load_command*) (((unsigned long) mh) + offset);
 435       if (LC_ID_DYLIB == lc->cmd)
 436         {
 437           result=(char*)(((dylib_command*) lc)->dylib.name.offset +
 438                          (unsigned long) lc);
 439         }
 440       offset += lc->cmdsize;
 441     }
 442 
 443   return result;
 444 }
 445 
 446 static const mach_header *
 447 lt__match_loadedlib (const char *name)
     /*  */
 448 {
 449   const mach_header *mh = 0;
 450   int i = _dyld_image_count();
 451 
 452   while (i > 0)
 453     {
 454       const char *id;
 455 
 456       --i;
 457       id = lt__header_get_instnam (_dyld_get_image_header (i));
 458       if (id && strneq (id, name))
 459         {
 460           mh = _dyld_get_image_header (i);
 461           break;
 462         }
 463     }
 464 
 465   return mh;
 466 }
 467 
 468 /* Safe to assume our mh is good. */
 469 static NSSymbol
 470 lt__linkedlib_symbol (const char *symname, const mach_header *mh)
     /*  */
 471 {
 472   NSSymbol symbol = 0;
 473 
 474   if (lt__image_symbol && NSIsSymbolNameDefined (symname))
 475     {
 476       unsigned long offset = sizeof(mach_header);
 477       struct load_command *lc;
 478       int j;
 479 
 480       for (j = 0; j < mh->ncmds; j++)
 481         {
 482           lc = (struct load_command*) (((unsigned long) mh) + offset);
 483           if ((LC_LOAD_DYLIB == lc->cmd) || (LC_LOAD_WEAK_DYLIB == lc->cmd))
 484             {
 485               unsigned long base = ((dylib_command *) lc)->dylib.name.offset;
 486               char *name = (char *) (base + (unsigned long) lc);
 487               const mach_header *mh1 = lt__match_loadedlib (name);
 488 
 489               if (!mh1)
 490                 {
 491                   /* Maybe NSAddImage can find it */
 492                   mh1 = lt__addimage (name,
 493                                       NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
 494                                       | NSADDIMAGE_OPTION_WITH_SEARCHING
 495                                       | NSADDIMAGE_OPTION_RETURN_ON_ERROR);
 496                 }
 497 
 498               if (mh1)
 499                 {
 500                   symbol = lt__image_symbol (mh1, symname, LT__SYMLOOKUP_OPTS);
 501                   if (symbol)
 502                     break;
 503                 }
 504             }
 505 
 506           offset += lc->cmdsize;
 507         }
 508     }
 509 
 510   return symbol;
 511 }
/* */
root/libltdl/loaders/dyld.c

DEFINITIONS
