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 refernce 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 GStaticPrivate module_error_private = G_STATIC_PRIVATE_INIT;
  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_static_private_set (&module_error_private, error, g_free);
 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 GStaticRecMutex g_module_global_lock = G_STATIC_REC_MUTEX_INIT;
 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_static_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_static_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_static_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_static_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 (",
 497                                file_name ? file_name : "NULL",
 498                                ") initialization check failed: ",
 499                                check_failed, NULL);
 500           g_module_close (module);
 501           module = NULL;
 502           g_module_set_error (error);
 503           g_free (error);
 504         }
 505       else
 506         g_module_set_error (saved_error);
 507
 508       g_free (saved_error);
 509     }
 510
 511   if (module != NULL &&
 512       (module_debug_flags & G_MODULE_DEBUG_RESIDENT_MODULES))
 513     g_module_make_resident (module);
 514
 515   g_static_rec_mutex_unlock (&g_module_global_lock);
 516   return module;
 517 }
 518
 519 #if defined (G_OS_WIN32) && !defined(_WIN64)
 520
 521 #undef g_module_open
 522
 523 GModule*
 524 g_module_open (const gchar    *file_name,
 525                GModuleFlags    flags)
 526 {
 527   gchar *utf8_file_name = g_locale_to_utf8 (file_name, -1, NULL, NULL, NULL);
 528   GModule *retval = g_module_open_utf8 (utf8_file_name, flags);
 529
 530   g_free (utf8_file_name);
 531
 532   return retval;
 533 }
 534
 535 #endif
 536
 537 gboolean
 538 g_module_close (GModule        *module)
 539 {
 540   SUPPORT_OR_RETURN (FALSE);
 541
 542   g_return_val_if_fail (module != NULL, FALSE);
 543   g_return_val_if_fail (module->ref_count > 0, FALSE);
 544
 545   g_static_rec_mutex_lock (&g_module_global_lock);
 546
 547   module->ref_count--;
 548
 549   if (!module->ref_count && !module->is_resident && module->unload)
 550     {
 551       GModuleUnload unload;
 552
 553       unload = module->unload;
 554       module->unload = NULL;
 555       unload (module);
 556     }
 557
 558   if (!module->ref_count && !module->is_resident)
 559     {
 560       GModule *last;
 561       GModule *node;
 562
 563       last = NULL;
 564
 565       node = modules;
 566       while (node)
 567         {
 568           if (node == module)
 569             {
 570               if (last)
 571                 last->next = node->next;
 572               else
 573                 modules = node->next;
 574               break;
 575             }
 576           last = node;
 577           node = last->next;
 578         }
 579       module->next = NULL;
 580
 581       _g_module_close (module->handle, FALSE);
 582       g_free (module->file_name);
 583 #if defined (G_OS_WIN32) && !defined(_WIN64)
 584       g_free (module->cp_file_name);
 585 #endif
 586       g_free (module);
 587     }
 588
 589   g_static_rec_mutex_unlock (&g_module_global_lock);
 590   return g_module_error() == NULL;
 591 }
 592
 593 void
 594 g_module_make_resident (GModule *module)
 595 {
 596   g_return_if_fail (module != NULL);
 597
 598   module->is_resident = TRUE;
 599 }
 600
 601 G_CONST_RETURN gchar*
 602 g_module_error (void)
 603 {
 604   return g_static_private_get (&module_error_private);
 605 }
 606
 607 gboolean
 608 g_module_symbol (GModule        *module,
 609                  const gchar    *symbol_name,
 610                  gpointer       *symbol)
 611 {
 612   const gchar *module_error;
 613
 614   if (symbol)
 615     *symbol = NULL;
 616   SUPPORT_OR_RETURN (FALSE);
 617
 618   g_return_val_if_fail (module != NULL, FALSE);
 619   g_return_val_if_fail (symbol_name != NULL, FALSE);
 620   g_return_val_if_fail (symbol != NULL, FALSE);
 621
 622   g_static_rec_mutex_lock (&g_module_global_lock);
 623
 624 #ifdef  G_MODULE_NEED_USCORE
 625   {
 626     gchar *name;
 627
 628     name = g_strconcat ("_", symbol_name, NULL);
 629     *symbol = _g_module_symbol (module->handle, name);
 630     g_free (name);
 631   }
 632 #else   /* !G_MODULE_NEED_USCORE */
 633   *symbol = _g_module_symbol (module->handle, symbol_name);
 634 #endif  /* !G_MODULE_NEED_USCORE */
 635
 636   module_error = g_module_error ();
 637   if (module_error)
 638     {
 639       gchar *error;
 640
 641       error = g_strconcat ("`", symbol_name, "': ", module_error, NULL);
 642       g_module_set_error (error);
 643       g_free (error);
 644       *symbol = NULL;
 645     }
 646
 647   g_static_rec_mutex_unlock (&g_module_global_lock);
 648   return !module_error;
 649 }
 650
 651 G_CONST_RETURN gchar*
 652 g_module_name (GModule *module)
 653 {
 654   g_return_val_if_fail (module != NULL, NULL);
 655
 656   if (module == main_module)
 657     return "main";
 658
 659   return module->file_name;
 660 }
 661
 662 #if defined (G_OS_WIN32) && !defined(_WIN64)
 663
 664 #undef g_module_name
 665
 666 G_CONST_RETURN gchar*
 667 g_module_name (GModule *module)
 668 {
 669   g_return_val_if_fail (module != NULL, NULL);
 670
 671   if (module == main_module)
 672     return "main";
 673
 674   return module->cp_file_name;
 675 }
 676
 677 #endif
 678
 679 gchar*
 680 g_module_build_path (const gchar *directory,
 681                      const gchar *module_name)
 682 {
 683   g_return_val_if_fail (module_name != NULL, NULL);
 684
 685   return _g_module_build_path (directory, module_name);
 686 }