mplayer.hg: loader/module.c comparison

comparison loader/module.c @ 2069:ce45cce7f7a5

sync with avifile

author	arpi
date	Thu, 04 Oct 2001 02:21:47 +0000
parents	d8c1b0b38edc
children	958d10763c34

comparison

equal deleted inserted replaced

-:3189c317dfc1
+:ce45cce7f7a5
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/mman.h>
 #include <sys/types.h>
-#ifdef HAVE_LIBDL
-#include <wine/elfdll.h>
-#include <dlfcn.h>
-#endif
 /*
 #ifdef __linux__
 #include <asm/unistd.h>
 #include <asm/ldt.h>
 #else
 #include <wine/winerror.h>
 #include <wine/heap.h>
 #include <wine/module.h>
 #include <wine/pe_image.h>
 #include <wine/debugtools.h>
+#ifdef HAVE_LIBDL
+#include <dlfcn.h>
+#include <wine/elfdll.h>
+#endif
 #include "win32.h"
 struct modref_list_t;
 typedef struct modref_list_t
 {
 WINE_MODREF* wm;
 struct modref_list_t *next;
 struct modref_list_t *prev;
 }
 modref_list;
 //WINE_MODREF *local_wm=NULL;
 modref_list* local_wm=NULL;
+//HANDLE SegptrHeap;  // unused?
 WINE_MODREF *MODULE_FindModule(LPCSTR m)
 {
 modref_list* list=local_wm;
 TRACE("Module %s request\n", m);
 {
 	TRACE("%s: %x\n", list->wm->filename, list->wm->module);
 	list=list->prev;
 	if(list==NULL)
 	    return NULL;
 }
 TRACE("Resolved to %s\n", list->wm->filename);
 return list->wm;
 }
 static void MODULE_RemoveFromList(WINE_MODREF *mod)
 {
 modref_list* list=local_wm;
 if(list==0)
 		local_wm=list->prev;
 	    free(list);
 	    return;
 	}
 }
 }
 WINE_MODREF *MODULE32_LookupHMODULE(HMODULE m)
 {
 modref_list* list=local_wm;
 TRACE("Module %X request\n", m);
 if(list==NULL)
 //      printf("Checking list %X wm %X module %X\n",
 //	list, list->wm, list->wm->module);
 	list=list->prev;
 	if(list==NULL)
 	    return NULL;
 }
-TRACE("LookupHMODULE hit %X\n", list->wm);
+TRACE("LookupHMODULE hit %p\n", list->wm);
 return list->wm;
 }
 /*************************************************************************
 *		MODULE_InitDll
 */
 static WIN_BOOL MODULE_InitDll( WINE_MODREF *wm, DWORD type, LPVOID lpReserved )
 {
 WIN_BOOL retv = TRUE;
 static LPCSTR typeName[] = { "PROCESS_DETACH", "PROCESS_ATTACH",
 "THREAD_ATTACH", "THREAD_DETACH" };
 assert( wm );
 /* Skip calls for modules loaded with special load flags */
 return retv;
 }
 /*************************************************************************
 *		MODULE_DllProcessAttach
 *
 * Send the process attach notification to all DLLs the given module
 * depends on (recursively). This is somewhat complicated due to the fact that
 *
 * - we have to respect the module dependencies, i.e. modules implicitly
 *   referenced by another module have to be initialized before the module
 *   itself can be initialized
 *
 * - the initialization routine of a DLL can itself call LoadLibrary,
 *   thereby introducing a whole new set of dependencies (even involving
 *   the 'old' modules) at any time during the whole process
 *
 * (Note that this routine can be recursively entered not only directly
 *  from itself, but also via LoadLibrary from one of the called initialization
 *  routines.)
 *
 * Furthermore, we need to rearrange the main WINE_MODREF list to allow
 * the process *detach* notifications to be sent in the correct order.
 * This must not only take into account module dependencies, but also
 * 'hidden' dependencies created by modules calling LoadLibrary in their
 * attach notification routine.
 *
 * The strategy is rather simple: we move a WINE_MODREF to the head of the
 * list after the attach notification has returned.  This implies that the
 else
 {
 	local_wm=malloc(sizeof(modref_list));
 	local_wm->next=local_wm->prev=NULL;
 	local_wm->wm=wm;
 }
 /* Remove recursion flag */
 wm->flags &= ~WINE_MODREF_MARKER;
 if ( retv )
 {
 retv = MODULE_InitDll( wm, DLL_PROCESS_ATTACH, lpReserved );
 if ( retv )
 wm->flags |= WINE_MODREF_PROCESS_ATTACHED;
 return retv;
 }
 /*************************************************************************
 *		MODULE_DllProcessDetach
 *
 * Send DLL process detach notifications.  See the comment about calling
 * sequence at MODULE_DllProcessAttach.  Unless the bForceDetach flag
 * is set, only DLLs with zero refcount are notified.
 */
 void MODULE_DllProcessDetach( WINE_MODREF* wm, WIN_BOOL bForceDetach, LPVOID lpReserved )
 {
 /***********************************************************************
 *           LoadLibraryExA   (KERNEL32)
 */
 HMODULE WINAPI LoadLibraryExA(LPCSTR libname, HANDLE hfile, DWORD flags)
 {
-	WINE_MODREF *wm;
+	WINE_MODREF *wm = 0;
+	char* listpath[] = { "", "", "/usr/lib/win32", "/usr/local/lib/win32", 0 };
+	extern char* def_path;
+	char path[512];
+	char checked[2000];
+int i = -1;
+checked[0] = 0;
 	if(!libname)
 	{
 		SetLastError(ERROR_INVALID_PARAMETER);
 		return 0;
 	}
+	printf("Loading DLL: '%s'\n", libname);
 //	if(fs_installed==0)
 //	    install_fs();
+	while (wm == 0 && listpath[++i])
-	wm = MODULE_LoadLibraryExA( libname, hfile, flags );
+	{
+	    if (i < 2)
+	    {
+		if (i == 0)
+		    /* check just original file name */
+		    strncpy(path, libname, 511);
+else
+		    /* check default user path */
+		    strncpy(path, def_path, 300);
+	    }
+	    else if (strcmp(def_path, listpath[i]))
+/* path from the list */
+		strncpy(path, listpath[i], 300);
+	    else
+		continue;
+	    if (i > 0)
+	    {
+		strcat(path, "/");
+		strncat(path, libname, 100);
+	    }
+	    path[511] = 0;
+	    wm = MODULE_LoadLibraryExA( path, hfile, flags );
+	    if (!wm)
+	    {
+		if (checked[0])
+		    strcat(checked, ", ");
+		strcat(checked, path);
+checked[1500] = 0;
+	    }
+	}
 	if ( wm )
 	{
 		if ( !MODULE_DllProcessAttach( wm, NULL ) )
 		{
 			WARN_(module)("Attach failed for module '%s', \n", libname);
 			MODULE_RemoveFromList(wm);
 			wm = NULL;
 		}
 	}
+	if (!wm)
+	    printf("Win32 LoadLibrary failed to load: %s\n", checked);
 	return wm ? wm->module : 0;
 }
 /***********************************************************************
 {
 	DWORD err = GetLastError();
 	WINE_MODREF *pwm;
 	int i;
 //	module_loadorder_t *plo;
 SetLastError( ERROR_FILE_NOT_FOUND );
 	TRACE("Trying native dll '%s'\n", libname);
 	pwm = PE_LoadLibraryExA(libname, flags);
 #ifdef HAVE_LIBDL
 	if(!pwm)
 	{
 	    TRACE("Trying ELF dll '%s'\n", libname);
 	    pwm=(WINE_MODREF*)ELFDLL_LoadLibraryExA(libname, flags);
 	}
 #endif
 //		printf("0x%08x\n", pwm);
 //		break;
 	if(pwm)
 	{
 		/* Initialize DLL just loaded */
 SetLastError( err );  /* restore last error */
 		return pwm;
 	}
 	WARN("Failed to load module '%s'; error=0x%08lx, \n", libname, GetLastError());
 	return NULL;
 }
 /***********************************************************************
 if ( !wm || !hLibModule )
 {
 SetLastError( ERROR_INVALID_HANDLE );
 	return 0;
 }
 else
 retv = MODULE_FreeLibrary( wm );
 MODULE_RemoveFromList(wm);
 /* garbage... */
 if (local_wm == NULL) my_garbagecollection();
 }
 /***********************************************************************
 *           MODULE_GetProcAddress   		(internal)
 */
 FARPROC MODULE_GetProcAddress(
 	HMODULE hModule, 	/* [in] current module handle */
 	LPCSTR function,	/* [in] function to be looked up */
 	WIN_BOOL snoop )
 {
 WINE_MODREF	*wm = MODULE32_LookupHMODULE( hModule );
 //    WINE_MODREF *wm=local_wm;
 FARPROC	retproc;
 if (HIWORD(function))
 	TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function);
 else
 {
 case MODULE32_PE:
 	retproc = PE_FindExportedFunction( wm, function, snoop );
 	if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND);
 	return retproc;
 #ifdef HAVE_LIBDL
 case MODULE32_ELF:
-	retproc = (FARPROC) dlsym( (void*)wm->module, function);
+	retproc = (FARPROC) dlsym( (void*) wm->module, function);
 	if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND);
 	return retproc;
 #endif
 default:
 	ERR("wine_modref type %d not handled.\n",wm->type);

Mercurial > mplayer.hg

comparison loader/module.c @ 2069:ce45cce7f7a5