/*
 * dlfcn.c
 *
 * Core implementation for (approximately) POSIX conforming dlopen(),
 * dlsym(), dlclose(), and dlerror() API functions.
 *
 * $Id: dlfcn.c,v fbab264d5f1d 2014/11/11 18:13:14 keithmarshall $
 *
 * Written by Keith Marshall <keithmarshall@users.sourceforge.net>
 * Copyright (C) 2014, MinGW.org Project
 *
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice, this permission notice, and the following
 * disclaimer shall be included in all copies or substantial portions of
 * the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OF OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 *
 * This source file implements the core functionality for each of the POSIX
 * dynamic loader API functions, dlopen(), dlsym(), dlclose(), and dlerror();
 * each is implemented such that it is conveniently accessed via a macro, or
 * an inline function representation, by way of a publicly visible table of
 * entry point vectors (i.e. function pointers).
 *
 */
#include <dlfcn.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>

/* In addition to normal C runtime services, this implementation requires
 * the use of the MS-Windows API; the light-weight subset will suffice...
 */
#define WIN32_LEAN_AND_MEAN
/*
 * ...while accessing it throught its standard interface.
 */
#include <windows.h>

/* In addition to the POSIX constants which are defined in dlfcn.h,
 * we also define some private manifest constants, which POSIX does
 * not specify, but which facilitate our implementation:
 *
 *   RTLD_EXPLICIT, used to qualify RTLD_GLOBAL modules which have
 *   been explicitly loaded by dlopen(), so an RTLD_DEFAULT search
 *   need not consider them.
 */
# define RTLD_EXPLICIT     16
/*
 *   RTLD_ALL_GLOBAL, returned by dlopen() when the module name is
 *   given as a NULL pointer; this is a fake module handle, similar
 *   to RTLD_DEFAULT and RTLD_NEXT, representing the corpus of all
 *   RTLD_GLOBAL modules, both implicitly and explicitly loaded.
 */
# define RTLD_ALL_GLOBAL  (void *)(-5)

/* Before anything else, ensure that the dlerror() implementation
 * is in place, so that other components may access it freely.
 *
 * We provide TWO reference pointers for error message buffering, so
 * that we may continue to hold a reference to allocated memory, even
 * after dlerror() has discarded the pointer to a pending message;
 * initially, we mark both as unassigned.
 */
static char *dlfcn_error_pending = NULL;
static char *dlfcn_error_message = NULL;

static void dlfcn_store_error_message( const char *fmt, ... )
{
  /* This private function provides printf() style formatting for
   * dlfcn error messages, storing them into dynamically allocated
   * memory, and updating both reference pointers for subsequent
   * retrieval by the dlerror() accessor function.
   */
  int msglen;
  va_list argv;
  va_start( argv, fmt );
  msglen = 1 + vsnprintf( NULL, 0, fmt, argv );
  if( (dlfcn_error_pending = realloc( dlfcn_error_message, msglen )) != NULL )
    /*
     * Store message, only if a buffer was successfully allocated.
     */
    vsnprintf( dlfcn_error_pending, msglen, fmt, argv );
  dlfcn_error_message = dlfcn_error_pending;
  va_end( argv );
}

static char *dlfcn_strerror( int errcode )
{
  /* This private function emulates strerror(), but substitutes an
   * errcode obtained from GetLastError() for errno.
   */
  char *text;
  uint32_t description = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
      | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
      errcode, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), (char *)(&text),
      0, NULL
    );
  if( description )
  {
    /* We successfully obtained an error description; POSIX insists
     * that it must not be encoded with any terminating newline.
     */
    char *tmp = text + strlen( text );
    while( (*--tmp == '\n') || (*tmp == '\r') ) *tmp = '\0';

    /* Ensure that we consistently return the error description in
     * a buffer which may be released by the free() function, (since
     * we cannot be sure that LocalFree() is compatible).
     */
    text = strdup( tmp = text );
    LocalFree( tmp );
  }
  else
  { /* We were unable to find an error description; substitute a
     * formatted reference to the unknown error code.
     */
    char *fmt = "Unknown error %d";
    char tmp[1 + snprintf( NULL, 0, fmt, errcode )];
    snprintf( tmp, sizeof( tmp ), fmt, errcode );
    text = strdup( tmp );
  }
  /* However we derived it, the error description is now available
   * in a dynamically allocated text buffer which may be released
   * by calling free().
   */
  return text;
}

static char *dlerror_internal( void )
{
  /* This is the internal implementation of the public dlerror() API.
   * POSIX does not require this to be thread safe, so we take no care
   * to make it such.
   */
  if( (dlfcn_error_pending == NULL) && (dlfcn_error_message != NULL) )
  {
    /* There is no pending message, but a buffer remains allocated
     * to one which has already been retrieved; we may release it.
     */
    free( dlfcn_error_message );
    dlfcn_error_message = NULL;
  }
  /* Mark any pending error message as "retrieved"...
   */
  dlfcn_error_pending = NULL;
  /*
   * ...and return it.
   */
  return dlfcn_error_message;
}

typedef
/* A pointer type, representing a reference to a function for
 * retrieving exported symbol references from any loaded module.
 */
int WINAPI (*lookup_fn)( HANDLE, HMODULE *, uint32_t, uint32_t * );

/* POSIX requires that dlsym() be able to look up symbol references
 * for any dynamically loaded module within the address space of the
 * calling process, including those which have been implicitly loaded
 * at process start-up.  To facilitate this, we will use Microsoft's
 * PSAPI.DLL services, to enumerate such implicitly loaded modules,
 * before we explicitly load any using dlopen(), or we perform any
 * look-up using dlsym() itself.
 */
static struct
{ /* Structure providing a convenient encapsulation of the PSAPI.DLL
   * interface, which may itself need to be explicitly loaded.
   */
  HMODULE	 dll;
  const char	*dll_name;
  const char	*lookup_fn_name;
  lookup_fn	 lookup;
}
psapi = { NULL, "psapi.dll", "EnumProcessModules", NULL };

/* The two NULL fields, within the preceding structure, must be
 * initialized before use; the following pair of inline functions
 * facilitate this, with the first looking up the API entry...
 */
static __inline__ lookup_fn psapi_lookup_fn( HMODULE provider )
{ return (lookup_fn)(GetProcAddress( provider, psapi.lookup_fn_name )); }

/* ...when called from within the second, which both ensures that
 * PSAPI.DLL is loaded, and assigns the requisite field values.
 */
static __inline__ lookup_fn psapi_lookup_fn_init( void )
{ return psapi.lookup = ((psapi.dll = LoadLibrary( psapi.dll_name )) != NULL)
    ? psapi_lookup_fn( psapi.dll ) : NULL;
}

/* After the PSAPI.DLL interface has been initialized, by calling
 * the preceding function, we may call the following inline helper
 * to retrieve a list of module handles...
 */
static __inline__ unsigned int psapi_enum_modules( HMODULE **modules )
{
  /* ...focussing on modules which are currently loaded within
   * the address space of the current process.
   */
  HANDLE me = GetCurrentProcess();

  /* We will dynamically allocate memory to store the handles;
   * initially we request zero bytes of storage to receive them,
   * then we use a while loop, which should execute exactly twice,
   * to retrieve them; on the first pass, we determine the actual
   * memory requirement and allocate it; on the second, we store
   * the list of module handles into it...
   */
  uint32_t wanted, request = 0;
  while( psapi.lookup( me, *modules, request, &wanted ) && (wanted > request) )
    if( (*modules = realloc( *modules, request = wanted )) == NULL )
    {
      /* ...trying to record an appropriate diagnostic message on
       * failure, (but noting that failure is likely to result from
       * insufficient memory, so there may not be enough to record
       * the message either)...
       */
      char *reason = dlfcn_strerror( ERROR_OUTOFMEMORY );
      dlfcn_store_error_message( "dlfcn_init:enum_modules: %s", reason );
      free( reason );
    }
  /* ...before ultimately returning the number retrieved.
   */
  return wanted / sizeof( HMODULE );
}

typedef struct dltab
{
  /* Structure used to map module handle references, and associated
   * status, into the global modules list.
   */
  unsigned int   slots;
  unsigned char *flags;
  HMODULE	*modules;
} dltab;

/* The global modules list itself, initially empty, but suitable
 * for reallocation on the heap.
 */
static dltab rtld = { 0, NULL, NULL };

/* Microsoft's LoadLibrary() API is explicitly documented as being
 * unable to handle regular slashes as directory separators in module
 * path names, (in spite of their validity elsewhere), thus...
 */
static __inline__ wchar_t *normalized_form( wchar_t *pathname )
{
  /* ...we provide this helper, to replace them with backslashes.
   */
  wchar_t *scan = pathname;
  do { if( *scan == L'/' ) *scan = L'\\'; } while( *scan++ != L'\0' );
  return pathname;
}

static void dlopen_store_error_message( const char *name, unsigned status )
{
  /* A convenience helper, to record diagnostic messages to explain
   * causes of failure encountered when calling dlopen().
   */
  char *reason = dlfcn_strerror( status );
  dlfcn_store_error_message( "dlopen:'%s': %s", name, reason );
  free( reason );
}

static void *dlopen_internal( const char *name, int mode )
{
  /* This is the formal implementation of the public dlopen() function;
   * note that this (currently) ignores the RTLD_LAZY loading option, and
   * processes each request as if specified as RTLD_NOW.
   */
  if( name == NULL )
    /* POSIX specifies this as a special case, requiring us to return
     * a handle, through which all symbols exported by all modules which
     * are currently loaded with the RTLD_GLOBAL attribute, (explicitly
     * or implicitly), would be accessible.
     */
    return RTLD_ALL_GLOBAL;

  /* We will use LoadLibrary() to obtain a handle for the dlopen()ed
   * module; Microsoft advise us that we should ensure that we always
   * use backslashes, and to avoid use of POSIX compatible slashes, in
   * any path name passed to this function.  To ensure this, the name
   * argument should be normalized, (working in the UTF-16LE domain,
   * to avoid inadvertent transformation of trail bytes within MBC
   * sequences), to transform slashes accordingly.
   */
  size_t buflen; wchar_t internal_name[buflen = 1 + strlen( name )];
  MultiByteToWideChar( CP_ACP, 0, name, -1, internal_name, buflen );

  /* Now, we may safely call LoadLibrary(), to obtain a module handle.
   */
  void *module = LoadLibraryW( normalized_form( internal_name ) );
  if( module == NULL )
  {
    /* The named module could not be opened; record an appropriate
     * error message for retrieval by dlerror().
     */
    dlopen_store_error_message( name, GetLastError() );
  }
  else
  { /* We got a handle for the requested module; we need to ensure
     * that it is allocated a slot in our global symbol table, but we
     * must first check that it isn't already present.
     */
    int index, insertion_point = rtld.slots;
    for( index = 0; index < rtld.slots; index++ )
    {
      /* As we scan the list of already loaded modules, check for any
       * existing slot which may be vacant...
       */
      if( rtld.flags[index] == 0 )
      {
	/* ...marking the first available, if any, as a candidate for
	 * possible insertion of a new entry.
	 */
	if( index < insertion_point )
	  insertion_point = index;
      }
      else if( module == rtld.modules[index] )
      {
	/* The requested module appears to be loaded already; calling
	 * LoadLibrary() will have increased its reference count, but
	 * our management strategy doesn't require this; reduce it...
	 */
	FreeLibrary( module );
	/*
	 * ...but promote its existing status to RTLD_GLOBAL, if that
	 * is indicated as required by the requested mode...
	 */
	rtld.flags[index] |= mode & RTLD_GLOBAL;
	/*
	 * ...and immediately return the module handle.
	 */
	return module;
      }
    }
    /* If we get to here, there is no entry for the requested module,
     * within the global modules list; we must add it now, either using
     * an existing vacant slot, if there is one...
     */
    if( insertion_point < rtld.slots )
    {
      /* ...but noting that we cannot simply insert a new reference
       * within it, since that would disrupt the order in which modules
       * are subsequently searched, and POSIX requires that this is to
       * preserve loading order, (strictly, symbol resolution order),
       * when searching RTLD_GLOBAL modules, (and since any module may
       * be promoted to RTLD_GLOBAL status, even after it was originally
       * loaded as RTLD_LOCAL, this means that we must preserve loading
       * order for ALL active modules).  Thus, we must pack the list of
       * active modules after the nominated insertion point...
       */
      index = insertion_point;

      /* ...after which, the first vacant slot will have been relocated
       * to follow all active slots, and we may adjust the nominated
       * insertion point accordingly.
       */
      do { /* First, we identify the first slot following the nominated
	    * insertion point, which is NOT vacant.
	    */
	   while( (index < rtld.slots) && (rtld.flags[index] == 0) )
	     ++index;

	   /* Now, we move that non-vacant slot, and any which follow
	    * it, upwards in the list, to fill vacant slots...
	    */
	   while( (index < rtld.slots) && (rtld.flags[index] != 0) )
	   {
	     /* ...by simply copying content from the non-vacant slots
	      * to overwrite content in the preceding slots...
	      */
	     rtld.modules[insertion_point] = rtld.modules[index];
	     rtld.flags[insertion_point++] = rtld.flags[index++];
	   }
	   /* ...repeating the entire procedure, until all vacant slots
	    * have been filled, and the nominated insertion point has
	    * been moved to follow the last relocated non-vacant entry.
	    */
	 } while( index < rtld.slots );

      /* After packing, any already allocated slots after and including
       * the relocated insertion point MUST be vacant; ensure that they
       * are marked accordingly.
       */
      for( index = insertion_point; index < rtld.slots; index++ )
	rtld.flags[index] = 0;
    }
    else
    { /* There is no vacant slot: we must expand the allocated memory
       * pool to create one; first increment the modules list size...
       */
      size_t slots = 1 + rtld.slots;
      HMODULE *modules = rtld.modules;
      if( (modules = realloc( modules, sizeof( HMODULE ) * slots )) != NULL )
      {
	/* ...and, having sucessfully increased the modules list memory
	 * allocation, do likewise for the associated flags...
	 */
	unsigned char *flags = rtld.flags;
	if( (flags = realloc( flags, slots )) != NULL )
	  /*
	   * ...initializing the new flags register, and incrementing
	   * the slots count, when that is also successful.
	   */
	  (rtld.flags = flags)[rtld.slots++] = 0;

	/* Regardless of the success, or otherwise, of the flags memory
	 * adjustment, the modules list was reallocated, so we need to
	 * adjust its reference pointer accordingly.
	 */
	rtld.modules = modules;
      }
      /* Before proceeding further, verify that the new slot has been
       * fully created, and is ready to store the module data...
       */
      if( insertion_point == rtld.slots )
      {
	/* ...but if allocation failed, the nominated insertion point
	 * will lie beyond the available space, so we MUST fail, after
	 * discarding the now unreferenced module handle, and trying to
	 * record an appropriate diagnostic message, (but we note that
	 * this may also fail, due to insufficient memory).
	 */
	FreeLibrary( module );
	dlopen_store_error_message( name, ERROR_OUTOFMEMORY );
	return NULL;
      }
    }
    /* When we get to here, we now have a suitable slot in which to add
     * the reference data for the newly dlopen()ed module, (either by
     * allocation of a new slot, or by relocation of an existing vacant
     * slot); we may safely store the appropriate reference data.
     */
    rtld.flags[insertion_point] = RTLD_EXPLICIT | mode;
    rtld.modules[insertion_point] = module;
  }
  /* Finally, we return whatever module handle we got from LoadLibrary(),
   * (which may be NULL, if this failed).
   */
  return module;
}

static void *dlsym_internal( void *module, const char *name )
{
  /* This is the formal implementation of the public dlsym() function.
   */
  static unsigned int index = 0;
  static const char *last_named_symbol = NULL;
  static unsigned char rtld_exclude = 0;
  void *rtn;

  if( module == RTLD_NEXT )
  {
    /* NOTE: We MUST identify this special case BEFORE any other!
     *
     * POSIX doesn't require this to be supported yet, but reserves it
     * for future use; it should cause dlsym() to repeat its search for
     * the named symbol, (provided it remains the same as last named in
     * a global search), continuing from the next module in the current
     * search order, following that in which the symbol was previously
     * found; (this permits us to locate symbols which may defined in
     * more than one loaded module).
     */
    index = (name == last_named_symbol) ? index + 1 : 0;
    module = RTLD_ALL_GLOBAL;
  }
  else if( module == RTLD_DEFAULT )
  {
    /* NOTE: We MUST keep this AFTER the check for RTLD_NEXT!
     *
     * Once again, POSIX doesn't require this to be supported yet, but
     * reserves it for future use to search for symbols which could have
     * been found within the process address space prior to any explicit
     * dlopen() call; this capability may be supported by searching all
     * modules in the address space, (i.e. equivalent to a search with
     * module == RTLD_ALL_GLOBAL), excluding those which have been
     * explicitly loaded since process start-up.
     */
    module = RTLD_ALL_GLOBAL;
    rtld_exclude = RTLD_EXPLICIT;
    index = 0;
  }
  else
    /* Neither RTLD_DEFAULT, nor RTLD_NEXT was specified; we must reset
     * the RTLD_GLOBAL search index, and cancel all search exclusions.
     */
    index = rtld_exclude = 0;

  if( module == RTLD_ALL_GLOBAL )
  {
    /* The RTLD_ALL_GLOBAL module reference represents a request to
     * perform an in-order traversal of all modules within the process
     * address space, either implicitly loaded, or explicitly loaded
     * with the RTLD_GLOBAL mode attribute, either until the named
     * symbol is found, or all such modules have been searched
     * without finding it.
     */ 
    for( rtn = NULL; (rtn == NULL) && (index < rtld.slots); index++ )
      if( ((rtld_exclude & rtld.flags[index]) == 0)
      &&  ((rtld.flags[index] & RTLD_GLOBAL) == RTLD_GLOBAL)  )
	rtn = GetProcAddress( rtld.modules[index], name );

    /* Note the symbol named in the current search, so that we may
     * check for consistency in the event that the next search is
     * invoked as an RTLD_NEXT request.
     */
    last_named_symbol = name;
  }
  else
  { /* When a specific module reference is specified, confine the
     * search to the specified module alone...
     */
    rtn = GetProcAddress( (HMODULE)(module), name );

    /* ...and inhibit any attempt to follow this search with one
     * specifying RTLD_NEXT; (this would not be valid, since there
     * is no concept of a "next" module to be searched, when not
     * searching through an ordered list of modules).
     */
    last_named_symbol = NULL;
  }

  if( rtn == NULL )
  {
    /* The named symbol was not found in any module which was searched;
     * record the appropriate error message for retrieval by dlerror().
     */
    char *reason = dlfcn_strerror( GetLastError() );
    dlfcn_store_error_message( "dlsym:'%s': %s", name, reason );
    free( reason );
  }

  /* Return the symbol address, as assigned to the return value;
   * (this will be NULL, if the named symbol was not found).
   */
  return rtn;
}

static int dlclose_store_error_message( int status )
{
  /* A private helper function to record an appropriate dlerror()
   * message, on failure of dlclose().
   */
  char *reason = dlfcn_strerror( status = GetLastError() );
  dlfcn_store_error_message( "dlclose: %s", reason );
  free( reason );
  return status;
}

static __inline__ int dlclose_internal_check_for_error( int status )
{
  /* A private helper function to set the return status for dlclose(),
   * while also recording a dlerror() message, when status is "failed".
   */
  return (status == 0) ? dlclose_store_error_message( status ) : 0;
}

static int dlclose_internal( void *module )
{
  /* This is the formal implementation of the public dlclose() function;
   * it will call Microsoft's FreeLibrary() function passing the specified
   * module handle, provided this is listed in the global module table as
   * having been explicitly opened by our dlopen() function.
   */
  int index;
  for( index = 0; index < rtld.slots; index++ )
    if( module == rtld.modules[index] )
    {
      /* The specified module handle is present in the global modules list;
       * while we could simply call FreeLibrary() immediately, it may not be
       * prudent to do so in respect of implicitly loaded modules, but for
       * those which we have explicitly loaded...
       */
      if( ((rtld.flags[index] & RTLD_EXPLICIT) == RTLD_EXPLICIT)
      /*
       * ...and which can be successfully released by FreeLibrary()...
       */
      &&  (dlclose_internal_check_for_error( FreeLibrary( module )) == 0)  )
	/*
	 * ...we mark them as no longer available for dlsym() processing,
	 * and return immediately, indicating success...
	 */
	return rtld.flags[index] = 0;

      /* ...but when we didn't successfully release the module, we have
       * no need to continue the search for its handle in the global list
       * of modules, (because we've already found it); we may immediately
       * abandon the search.
       */
      break;
    }

  /* If we get to here, we either didn't find the specified module handle in
   * the global list of modules, or we found it but were unable to release
   * it; in either case, we force a module error condition.
   */
  return dlclose_store_error_message( FreeLibrary( NULL ) );
}

static void dlfcn_init( void )
{
  /* This private initialization function must be called, as a
   * prerequisite to the first use of either dlopen() or dlsym()
   * in any process; it uses Microsoft's PSAPI.DLL interface to
   * enumerate the implicitly loaded process modules, so that
   * they may be searched implicitly by dlsym().
   */
  if( psapi_lookup_fn_init() == NULL )
  {
    /* Initialization of the PSAPI.DLL interface failed.  Record
     * this for possible retrieval by dlerror(); we can do no more,
     * so the list of implicitly loaded mudules will remain empty.
     */
    char *reason = dlfcn_strerror( GetLastError() );
    dlfcn_store_error_message( "dlfcn_init:%s: %s", psapi.dll_name, reason );
    free( reason );
  }
  else
  { /* We've acquired a reference for the PSAPI EnumProcessModules()
     * service; invoke it, to obtain a list of all modules which are
     * currently accessible, within the address space of the current
     * process, (which we assume to represent all modules which were
     * loaded implicitly, at process start-up)...
     */
    rtld.slots = psapi_enum_modules( &(rtld.modules) );
    /*
     * ...but, noting that we explicitly added a refererence for the
     * PSAPI.DLL services interface, which we needed to acquire this
     * list, we may now discard that reference.
     */
    FreeLibrary( psapi.dll );

    /* Provided we've obtained a non-empty list of modules...
     */
    if(  (rtld.modules != NULL)
    /*
     * ...and we can successfully allocate storage for an associated
     * collection of flags registers, (one per module)...
     */
    &&  ((rtld.flags = realloc( rtld.flags, rtld.slots )) != NULL)  )
    {
      /* ...examine each reference in the modules list, and for each
       * which is not NULL...
       */
      unsigned int index;
      for( index = 0; index < rtld.slots; index++ )
	if( (rtld.modules[index] != NULL)
	/*
	 * ...and which is not the PSAPI.DLL reference we've already
	 * released...
	 */
	&&  ((rtld.modules[index] != psapi.dll)
	/*
	 * ...unless it continues to provide a valid reference to the
	 * PSAPI EnumProcessModules() service, (which indicates that
	 * the associated DLL had been implicitly loaded, BEFORE we
	 * explicitly requested it)...
	 */
	||  (psapi_lookup_fn( psapi.dll ) == psapi.lookup))  )
	  /*
	   * ...then we set the associated flags to indicate that the
	   * module was implicitly loaded and globally accessible...
	   */
	  rtld.flags[index] = RTLD_GLOBAL;
	else
	  /* ...otherwise, we mark it as if dlclose() has already been
	   * implicitly called, to discard it.
	   */
	  rtld.flags[index] = 0;

      /* Having thus populated the global modules list, on first call
       * to either dlopen() or dlsym(), we don't need to (and indeed we
       * shouldn't) do this again; redirect each of these two calls to
       * their respective internal handlers.
       */
      __mingw_dlfcn.dlopen = dlopen_internal;
      __mingw_dlfcn.dlsym = dlsym_internal;
    }
  }
}

/* The global symbol table needs to be initialized, before we process
 * the first call to either dlopen() or dlsym(); the following pair of
 * initializer functions take care of this requirement, before passing
 * the first-time request to the appropriate internal handler.
 */
static void *dlopen_init( const char *name, int mode )
{ dlfcn_init(); return dlopen_internal( name, mode ); }

static void *dlsym_init( void *module, const char *name )
{ dlfcn_init(); return dlsym_internal( module, name ); }

/* Finally, we may define the __mingw_dlfcn structure, and set up its
 * initial function pointers, referring to the four API functions...
 */
struct __dlfcn__ __mingw_dlfcn =
{ dlopen_init,		/* dlopen() implementation, with initialization. */
  dlsym_init,		/* dlsym() implementation, with initialization.  */
  dlerror_internal,	/* dlerror() implementation; (direct reference). */
  dlclose_internal	/* dlclose() implementation; (direct reference). */
};

/* $RCSfile: dlfcn.c,v $: end of file */
