gmodule/gmodule.c

   1 /* GMODULE - GLIB wrapper code for dynamic module loading
   2  * Copyright (C) 1998 Tim Janik
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GLib Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 /*
  28  * MT safe
  29  */
  30
  31 #include "config.h"
  32
  33 #include "glib.h"
  34 #include "gmodule.h"
  35
  36 #include <errno.h>
  37 #include <string.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <fcntl.h>
  41 #ifdef HAVE_UNISTD_H
  42 #include <unistd.h>
  43 #endif
  44 #ifdef G_OS_WIN32
  45 #include <io.h>         /* For open() and close() prototypes. */
  46 #endif
  47
  48 #include "gmoduleconf.h"
  49 #include "gstdio.h"
  50
  51 /* We maintain a list of modules, so we can reference count them.
  52  * That's needed because some platforms don't support references counts on
  53  * modules e.g. the shl_* implementation of HP-UX
  54  * (http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html).
  55  * Also, the module for the program itself is kept seperatedly for
  56  * faster access and because it has special semantics.
  57  */
  58
  59
  60 /* --- structures --- */
  61 struct _GModule
  62 {
  63   gchar *file_name;
  64 #if defined (G_OS_WIN32) && !defined(_WIN64)
  65   gchar *cp_file_name;
  66 #endif
  67   gpointer handle;
  68   guint ref_count : 31;
  69   guint is_resident : 1;
  70   GModuleUnload unload;
  71   GModule *next;
  72 };
  73
  74
  75 /* --- prototypes --- */
  76 static gpointer         _g_module_open          (const gchar    *file_name,
  77                                                  gboolean        bind_lazy,
  78                                                  gboolean        bind_local);
  79 static void             _g_module_close         (gpointer        handle,
  80                                                  gboolean        is_unref);
  81 static gpointer         _g_module_self          (void);
  82 static gpointer         _g_module_symbol        (gpointer        handle,
  83                                                  const gchar    *symbol_name);
  84 static gchar*           _g_module_build_path    (const gchar    *directory,
  85                                                  const gchar    *module_name);
  86 static inline void      g_module_set_error      (const gchar    *error);
  87 static inline GModule*  g_module_find_by_handle (gpointer        handle);
  88 static inline GModule*  g_module_find_by_name   (const gchar    *name);
  89
  90
  91 /* --- variables --- */
  92 static GModule       *modules = NULL;
  93 static GModule       *main_module = NULL;
  94 static GPrivate       module_error_private = G_PRIVATE_INIT (g_free);
  95 static gboolean       module_debug_initialized = FALSE;
  96 static guint          module_debug_flags = 0;
  97
  98
  99 /* --- inline functions --- */
 100 static inline GModule*
 101 g_module_find_by_handle (gpointer handle)
 102 {
 103   GModule *module;
 104   GModule *retval = NULL;
 105
 106   if (main_module && main_module->handle == handle)
 107     retval = main_module;
 108   else
 109     for (module = modules; module; module = module->next)
 110       if (handle == module->handle)
 111         {
 112           retval = module;
 113           break;
 114         }
 115
 116   return retval;
 117 }
 118
 119 static inline GModule*
 120 g_module_find_by_name (const gchar *name)
 121 {
 122   GModule *module;
 123   GModule *retval = NULL;
 124
 125   for (module = modules; module; module = module->next)
 126     if (strcmp (name, module->file_name) == 0)
 127         {
 128           retval = module;
 129           break;
 130         }
 131
 132   return retval;
 133 }
 134
 135 static inline void
 136 g_module_set_error_unduped (gchar *error)
 137 {
 138   g_private_replace (&module_error_private, error);
 139   errno = 0;
 140 }
 141
 142 static inline void
 143 g_module_set_error (const gchar *error)
 144 {
 145   g_module_set_error_unduped (g_strdup (error));
 146 }
 147
 148
 149 /* --- include platform specifc code --- */
 150 #define SUPPORT_OR_RETURN(rv)   { g_module_set_error (NULL); }
 151 #if     (G_MODULE_IMPL == G_MODULE_IMPL_DL)
 152 #include "gmodule-dl.c"
 153 #elif   (G_MODULE_IMPL == G_MODULE_IMPL_DLD)
 154 #include "gmodule-dld.c"
 155 #elif   (G_MODULE_IMPL == G_MODULE_IMPL_WIN32)
 156 #include "gmodule-win32.c"
 157 #elif   (G_MODULE_IMPL == G_MODULE_IMPL_DYLD)
 158 #include "gmodule-dyld.c"
 159 #elif   (G_MODULE_IMPL == G_MODULE_IMPL_AR)
 160 #include "gmodule-ar.c"
 161 #else
 162 #undef  SUPPORT_OR_RETURN
 163 #define SUPPORT_OR_RETURN(rv)   { g_module_set_error ("dynamic modules are " \
 164                                               "not supported by this system"); return rv; }
 165 static gpointer
 166 _g_module_open (const gchar     *file_name,
 167                 gboolean         bind_lazy,
 168                 gboolean         bind_local)
 169 {
 170   return NULL;
 171 }
 172 static void
 173 _g_module_close (gpointer        handle,
 174                  gboolean        is_unref)
 175 {
 176 }
 177 static gpointer
 178 _g_module_self (void)
 179 {
 180   return NULL;
 181 }
 182 static gpointer
 183 _g_module_symbol (gpointer       handle,
 184                   const gchar   *symbol_name)
 185 {
 186   return NULL;
 187 }
 188 static gchar*
 189 _g_module_build_path (const gchar *directory,
 190                       const gchar *module_name)
 191 {
 192   return NULL;
 193 }
 194 #endif  /* no implementation */
 195
 196 /* --- functions --- */
 197 gboolean
 198 g_module_supported (void)
 199 {
 200   SUPPORT_OR_RETURN (FALSE);
 201
 202   return TRUE;
 203 }
 204
 205 static gchar*
 206 parse_libtool_archive (const gchar* libtool_name)
 207 {
 208   const guint TOKEN_DLNAME = G_TOKEN_LAST + 1;
 209   const guint TOKEN_INSTALLED = G_TOKEN_LAST + 2;
 210   const guint TOKEN_LIBDIR = G_TOKEN_LAST + 3;
 211   gchar *lt_dlname = NULL;
 212   gboolean lt_installed = TRUE;
 213   gchar *lt_libdir = NULL;
 214   gchar *name;
 215   GTokenType token;
 216   GScanner *scanner;
 217
 218   int fd = g_open (libtool_name, O_RDONLY, 0);
 219   if (fd < 0)
 220     {
 221       gchar *display_libtool_name = g_filename_display_name (libtool_name);
 222       g_module_set_error_unduped (g_strdup_printf ("failed to open libtool archive \"%s\"", display_libtool_name));
 223       g_free (display_libtool_name);
 224       return NULL;
 225     }
 226   /* search libtool's dlname specification  */
 227   scanner = g_scanner_new (NULL);
 228   g_scanner_input_file (scanner, fd);
 229   scanner->config->symbol_2_token = TRUE;
 230   g_scanner_scope_add_symbol (scanner, 0, "dlname",
 231                               GUINT_TO_POINTER (TOKEN_DLNAME));
 232   g_scanner_scope_add_symbol (scanner, 0, "installed",
 233                               GUINT_TO_POINTER (TOKEN_INSTALLED));
 234   g_scanner_scope_add_symbol (scanner, 0, "libdir",
 235                               GUINT_TO_POINTER (TOKEN_LIBDIR));
 236   while (!g_scanner_eof (scanner))
 237     {
 238       token = g_scanner_get_next_token (scanner);
 239       if (token == TOKEN_DLNAME || token == TOKEN_INSTALLED ||
 240           token == TOKEN_LIBDIR)
 241         {
 242           if (g_scanner_get_next_token (scanner) != '=' ||
 243               g_scanner_get_next_token (scanner) !=
 244               (token == TOKEN_INSTALLED ?
 245                G_TOKEN_IDENTIFIER : G_TOKEN_STRING))
 246             {
 247               gchar *display_libtool_name = g_filename_display_name (libtool_name);
 248               g_module_set_error_unduped (g_strdup_printf ("unable to parse libtool archive \"%s\"", display_libtool_name));
 249               g_free (display_libtool_name);
 250
 251               g_free (lt_dlname);
 252               g_free (lt_libdir);
 253               g_scanner_destroy (scanner);
 254               close (fd);
 255
 256               return NULL;
 257             }
 258           else
 259             {
 260               if (token == TOKEN_DLNAME)
 261                 {
 262                   g_free (lt_dlname);
 263                   lt_dlname = g_strdup (scanner->value.v_string);
 264                 }
 265               else if (token == TOKEN_INSTALLED)
 266                 lt_installed =
 267                   strcmp (scanner->value.v_identifier, "yes") == 0;
 268               else /* token == TOKEN_LIBDIR */
 269                 {
 270                   g_free (lt_libdir);
 271                   lt_libdir = g_strdup (scanner->value.v_string);
 272                 }
 273             }
 274         }
 275     }
 276
 277   if (!lt_installed)
 278     {
 279       gchar *dir = g_path_get_dirname (libtool_name);
 280       g_free (lt_libdir);
 281       lt_libdir = g_strconcat (dir, G_DIR_SEPARATOR_S ".libs", NULL);
 282       g_free (dir);
 283     }
 284
 285   name = g_strconcat (lt_libdir, G_DIR_SEPARATOR_S, lt_dlname, NULL);
 286
 287   g_free (lt_dlname);
 288   g_free (lt_libdir);
 289   g_scanner_destroy (scanner);
 290   close (fd);
 291
 292   return name;
 293 }
 294
 295 static inline gboolean
 296 str_check_suffix (const gchar* string,
 297                   const gchar* suffix)
 298 {
 299   gsize string_len = strlen (string);
 300   gsize suffix_len = strlen (suffix);
 301
 302   return string_len >= suffix_len &&
 303     strcmp (string + string_len - suffix_len, suffix) == 0;
 304 }
 305
 306 enum
 307 {
 308   G_MODULE_DEBUG_RESIDENT_MODULES = 1 << 0,
 309   G_MODULE_DEBUG_BIND_NOW_MODULES = 1 << 1
 310 };
 311
 312 static void
 313 _g_module_debug_init (void)
 314 {
 315   const GDebugKey keys[] = {
 316     { "resident-modules", G_MODULE_DEBUG_RESIDENT_MODULES },
 317     { "bind-now-modules", G_MODULE_DEBUG_BIND_NOW_MODULES }
 318   };
 319   const gchar *env;
 320
 321   env = g_getenv ("G_DEBUG");
 322
 323   module_debug_flags =
 324     !env ? 0 : g_parse_debug_string (env, keys, G_N_ELEMENTS (keys));
 325
 326   module_debug_initialized = TRUE;
 327 }
 328
 329 static GRecMutex g_module_global_lock;
 330
 331 GModule*
 332 g_module_open (const gchar    *file_name,
 333                GModuleFlags    flags)
 334 {
 335   GModule *module;
 336   gpointer handle = NULL;
 337   gchar *name = NULL;
 338
 339   SUPPORT_OR_RETURN (NULL);
 340
 341   g_rec_mutex_lock (&g_module_global_lock);
 342
 343   if (G_UNLIKELY (!module_debug_initialized))
 344     _g_module_debug_init ();
 345
 346   if (module_debug_flags & G_MODULE_DEBUG_BIND_NOW_MODULES)
 347     flags &= ~G_MODULE_BIND_LAZY;
 348
 349   if (!file_name)
 350     {
 351       if (!main_module)
 352         {
 353           handle = _g_module_self ();
 354           if (handle)
 355             {
 356               main_module = g_new (GModule, 1);
 357               main_module->file_name = NULL;
 358 #if defined (G_OS_WIN32) && !defined(_WIN64)
 359               main_module->cp_file_name = NULL;
 360 #endif
 361               main_module->handle = handle;
 362               main_module->ref_count = 1;
 363               main_module->is_resident = TRUE;
 364               main_module->unload = NULL;
 365               main_module->next = NULL;
 366             }
 367         }
 368       else
 369         main_module->ref_count++;
 370
 371       g_rec_mutex_unlock (&g_module_global_lock);
 372       return main_module;
 373     }
 374
 375   /* we first search the module list by name */
 376   module = g_module_find_by_name (file_name);
 377   if (module)
 378     {
 379       module->ref_count++;
 380
 381       g_rec_mutex_unlock (&g_module_global_lock);
 382       return module;
 383     }
 384
 385   /* check whether we have a readable file right away */
 386   if (g_file_test (file_name, G_FILE_TEST_IS_REGULAR))
 387     name = g_strdup (file_name);
 388   /* try completing file name with standard library suffix */
 389   if (!name)
 390     {
 391       name = g_strconcat (file_name, "." G_MODULE_SUFFIX, NULL);
 392       if (!g_file_test (name, G_FILE_TEST_IS_REGULAR))
 393         {
 394           g_free (name);
 395           name = NULL;
 396         }
 397     }
 398   /* try completing by appending libtool suffix */
 399   if (!name)
 400     {
 401       name = g_strconcat (file_name, ".la", NULL);
 402       if (!g_file_test (name, G_FILE_TEST_IS_REGULAR))
 403         {
 404           g_free (name);
 405           name = NULL;
 406         }
 407     }
 408   /* we can't access() the file, lets hope the platform backends finds
 409    * it via library paths
 410    */
 411   if (!name)
 412     {
 413       gchar *dot = strrchr (file_name, '.');
 414       gchar *slash = strrchr (file_name, G_DIR_SEPARATOR);
 415
 416       /* make sure the name has a suffix */
 417       if (!dot || dot < slash)
 418         name = g_strconcat (file_name, "." G_MODULE_SUFFIX, NULL);
 419       else
 420         name = g_strdup (file_name);
 421     }
 422
 423   /* ok, try loading the module */
 424   if (name)
 425     {
 426       /* if it's a libtool archive, figure library file to load */
 427       if (str_check_suffix (name, ".la")) /* libtool archive? */
 428         {
 429           gchar *real_name = parse_libtool_archive (name);
 430
 431           /* real_name might be NULL, but then module error is already set */
 432           if (real_name)
 433             {
 434               g_free (name);
 435               name = real_name;
 436             }
 437         }
 438       if (name)
 439         handle = _g_module_open (name, (flags & G_MODULE_BIND_LAZY) != 0,
 440                         (flags & G_MODULE_BIND_LOCAL) != 0);
 441     }
 442   else
 443     {
 444       gchar *display_file_name = g_filename_display_name (file_name);
 445       g_module_set_error_unduped (g_strdup_printf ("unable to access file \"%s\"", display_file_name));
 446       g_free (display_file_name);
 447     }
 448   g_free (name);
 449
 450   if (handle)
 451     {
 452       gchar *saved_error;
 453       GModuleCheckInit check_init;
 454       const gchar *check_failed = NULL;
 455
 456       /* search the module list by handle, since file names are not unique */
 457       module = g_module_find_by_handle (handle);
 458       if (module)
 459         {
 460           _g_module_close (module->handle, TRUE);
 461           module->ref_count++;
 462           g_module_set_error (NULL);
 463
 464           g_rec_mutex_unlock (&g_module_global_lock);
 465           return module;
 466         }
 467
 468       saved_error = g_strdup (g_module_error ());
 469       g_module_set_error (NULL);
 470
 471       module = g_new (GModule, 1);
 472       module->file_name = g_strdup (file_name);
 473 #if defined (G_OS_WIN32) && !defined(_WIN64)
 474       module->cp_file_name = g_locale_from_utf8 (file_name, -1,
 475                                                  NULL, NULL, NULL);
 476 #endif
 477       module->handle = handle;
 478       module->ref_count = 1;
 479       module->is_resident = FALSE;
 480       module->unload = NULL;
 481       module->next = modules;
 482       modules = module;
 483
 484       /* check initialization */
 485       if (g_module_symbol (module, "g_module_check_init", (gpointer) &check_init) && check_init != NULL)
 486         check_failed = check_init (module);
 487
 488       /* we don't call unload() if the initialization check failed. */
 489       if (!check_failed)
 490         g_module_symbol (module, "g_module_unload", (gpointer) &module->unload);
 491
 492       if (check_failed)
 493         {
 494           gchar *error;
 495
 496           error = g_strconcat ("GModule (", file_name, ") ",
 497                                "initialization check failed: ",
 498                                check_failed, NULL);
 499           g_module_close (module);
 500           module = NULL;
 501           g_module_set_error (error);
 502           g_free (error);
 503         }
 504       else
 505         g_module_set_error (saved_error);
 506
 507       g_free (saved_error);
 508     }
 509
 510   if (module != NULL &&
 511       (module_debug_flags & G_MODULE_DEBUG_RESIDENT_MODULES))
 512     g_module_make_resident (module);
 513
 514   g_rec_mutex_unlock (&g_module_global_lock);
 515   return module;
 516 }
 517
 518 #if defined (G_OS_WIN32) && !defined(_WIN64)
 519
 520 #undef g_module_open
 521
 522 GModule*
 523 g_module_open (const gchar    *file_name,
 524                GModuleFlags    flags)
 525 {
 526   gchar *utf8_file_name = g_locale_to_utf8 (file_name, -1, NULL, NULL, NULL);
 527   GModule *retval = g_module_open_utf8 (utf8_file_name, flags);
 528
 529   g_free (utf8_file_name);
 530
 531   return retval;
 532 }
 533
 534 #endif
 535
 536 gboolean
 537 g_module_close (GModule        *module)
 538 {
 539   SUPPORT_OR_RETURN (FALSE);
 540
 541   g_return_val_if_fail (module != NULL, FALSE);
 542   g_return_val_if_fail (module->ref_count > 0, FALSE);
 543
 544   g_rec_mutex_lock (&g_module_global_lock);
 545
 546   module->ref_count--;
 547
 548   if (!module->ref_count && !module->is_resident && module->unload)
 549     {
 550       GModuleUnload unload;
 551
 552       unload = module->unload;
 553       module->unload = NULL;
 554       unload (module);
 555     }
 556
 557   if (!module->ref_count && !module->is_resident)
 558     {
 559       GModule *last;
 560       GModule *node;
 561
 562       last = NULL;
 563
 564       node = modules;
 565       while (node)
 566         {
 567           if (node == module)
 568             {
 569               if (last)
 570                 last->next = node->next;
 571               else
 572                 modules = node->next;
 573               break;
 574             }
 575           last = node;
 576           node = last->next;
 577         }
 578       module->next = NULL;
 579
 580       _g_module_close (module->handle, FALSE);
 581       g_free (module->file_name);
 582 #if defined (G_OS_WIN32) && !defined(_WIN64)
 583       g_free (module->cp_file_name);
 584 #endif
 585       g_free (module);
 586     }
 587
 588   g_rec_mutex_unlock (&g_module_global_lock);
 589   return g_module_error() == NULL;
 590 }
 591
 592 void
 593 g_module_make_resident (GModule *module)
 594 {
 595   g_return_if_fail (module != NULL);
 596
 597   module->is_resident = TRUE;
 598 }
 599
 600 const gchar *
 601 g_module_error (void)
 602 {
 603   return g_private_get (&module_error_private);
 604 }
 605
 606 gboolean
 607 g_module_symbol (GModule        *module,
 608                  const gchar    *symbol_name,
 609                  gpointer       *symbol)
 610 {
 611   const gchar *module_error;
 612
 613   if (symbol)
 614     *symbol = NULL;
 615   SUPPORT_OR_RETURN (FALSE);
 616
 617   g_return_val_if_fail (module != NULL, FALSE);
 618   g_return_val_if_fail (symbol_name != NULL, FALSE);
 619   g_return_val_if_fail (symbol != NULL, FALSE);
 620
 621   g_rec_mutex_lock (&g_module_global_lock);
 622
 623 #ifdef  G_MODULE_NEED_USCORE
 624   {
 625     gchar *name;
 626
 627     name = g_strconcat ("_", symbol_name, NULL);
 628     *symbol = _g_module_symbol (module->handle, name);
 629     g_free (name);
 630   }
 631 #else   /* !G_MODULE_NEED_USCORE */
 632   *symbol = _g_module_symbol (module->handle, symbol_name);
 633 #endif  /* !G_MODULE_NEED_USCORE */
 634
 635   module_error = g_module_error ();
 636   if (module_error)
 637     {
 638       gchar *error;
 639
 640       error = g_strconcat ("`", symbol_name, "': ", module_error, NULL);
 641       g_module_set_error (error);
 642       g_free (error);
 643       *symbol = NULL;
 644     }
 645
 646   g_rec_mutex_unlock (&g_module_global_lock);
 647   return !module_error;
 648 }
 649
 650 const gchar *
 651 g_module_name (GModule *module)
 652 {
 653   g_return_val_if_fail (module != NULL, NULL);
 654
 655   if (module == main_module)
 656     return "main";
 657
 658   return module->file_name;
 659 }
 660
 661 #if defined (G_OS_WIN32) && !defined(_WIN64)
 662
 663 #undef g_module_name
 664
 665 const gchar *
 666 g_module_name (GModule *module)
 667 {
 668   g_return_val_if_fail (module != NULL, NULL);
 669
 670   if (module == main_module)
 671     return "main";
 672
 673   return module->cp_file_name;
 674 }
 675
 676 #endif
 677
 678 gchar*
 679 g_module_build_path (const gchar *directory,
 680                      const gchar *module_name)
 681 {
 682   g_return_val_if_fail (module_name != NULL, NULL);
 683
 684   return _g_module_build_path (directory, module_name);
 685 }