reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-27 13:40:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
b88b08c2f1
wine/loader/loadorder.c
Francois Gouget e5ddd26dd7 When including config.h, include it first.
2001-10-14 16:18:52 +00:00

578 lines
18 KiB
C
Raw Blame History

/*
* Module/Library loadorder
*
* Copyright 1999 Bertho Stultiens
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "windef.h"
#include "winreg.h"
#include "winerror.h"
#include "options.h"
#include "file.h"
#include "module.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(module);
#define LOADORDER_ALLOC_CLUSTER 32 /* Allocate with 32 entries at a time */
typedef struct module_loadorder
{
const char *modulename;
enum loadorder_type loadorder[LOADORDER_NTYPES];
} module_loadorder_t;
struct loadorder_list
{
int count;
int alloc;
module_loadorder_t *order;
};
/* default load-order if nothing specified */
/* the list must remain sorted by dll name */
static module_loadorder_t default_order_list[] =
{
{ "display", { LOADORDER_BI, 0, 0, 0 } },
{ "gdi", { LOADORDER_BI, 0, 0, 0 } },
{ "gdi32", { LOADORDER_BI, 0, 0, 0 } },
{ "glide2x", { LOADORDER_SO, LOADORDER_DLL, 0, 0 } },
{ "glide3x", { LOADORDER_SO, LOADORDER_DLL, 0, 0 } },
{ "icmp", { LOADORDER_BI, 0, 0, 0 } },
{ "kernel", { LOADORDER_BI, 0, 0, 0 } },
{ "kernel32", { LOADORDER_BI, 0, 0, 0 } },
{ "keyboard", { LOADORDER_BI, 0, 0, 0 } },
{ "krnl386", { LOADORDER_BI, 0, 0, 0 } },
{ "mmsystem", { LOADORDER_BI, 0, 0, 0 } },
{ "mouse", { LOADORDER_BI, 0, 0, 0 } },
{ "ntdll", { LOADORDER_BI, 0, 0, 0 } },
{ "odbc32", { LOADORDER_BI, 0, 0, 0 } },
{ "system", { LOADORDER_BI, 0, 0, 0 } },
{ "toolhelp", { LOADORDER_BI, 0, 0, 0 } },
{ "ttydrv", { LOADORDER_BI, 0, 0, 0 } },
{ "user", { LOADORDER_BI, 0, 0, 0 } },
{ "user32", { LOADORDER_BI, 0, 0, 0 } },
{ "w32skrnl", { LOADORDER_BI, 0, 0, 0 } },
{ "winaspi", { LOADORDER_BI, 0, 0, 0 } },
{ "windebug", { LOADORDER_DLL, LOADORDER_BI, 0, 0 } },
{ "winedos", { LOADORDER_BI, 0, 0, 0 } },
{ "wineps", { LOADORDER_BI, 0, 0, 0 } },
{ "wing", { LOADORDER_BI, 0, 0, 0 } },
{ "winmm", { LOADORDER_BI, 0, 0, 0 } },
{ "winsock", { LOADORDER_BI, 0, 0, 0 } },
{ "wnaspi32", { LOADORDER_BI, 0, 0, 0 } },
{ "wow32", { LOADORDER_BI, 0, 0, 0 } },
{ "wprocs", { LOADORDER_BI, 0, 0, 0 } },
{ "ws2_32", { LOADORDER_BI, 0, 0, 0 } },
{ "wsock32", { LOADORDER_BI, 0, 0, 0 } },
{ "x11drv", { LOADORDER_BI, 0, 0, 0 } }
};
static const struct loadorder_list default_list =
{
sizeof(default_order_list)/sizeof(default_order_list[0]),
sizeof(default_order_list)/sizeof(default_order_list[0]),
default_order_list
};
static struct loadorder_list cmdline_list;
/***************************************************************************
* cmp_sort_func (internal, static)
*
* Sorting and comparing function used in sort and search of loadorder
* entries.
*/
static int cmp_sort_func(const void *s1, const void *s2)
{
return FILE_strcasecmp(((module_loadorder_t *)s1)->modulename,
((module_loadorder_t *)s2)->modulename);
}
/***************************************************************************
* get_tok (internal, static)
*
* strtok wrapper for non-destructive buffer writing.
* NOTE: strtok is not reentrant and therefore this code is neither.
*/
static char *get_tok(const char *str, const char *delim)
{
static char *buf = NULL;
char *cptr;
if(!str && !buf)
return NULL;
if(str && buf)
{
HeapFree(GetProcessHeap(), 0, buf);
buf = NULL;
}
if(str && !buf)
{
buf = HeapAlloc(GetProcessHeap(), 0, strlen(str)+1);
strcpy( buf, str );
cptr = strtok(buf, delim);
}
else
{
cptr = strtok(NULL, delim);
}
if(!cptr)
{
HeapFree(GetProcessHeap(), 0, buf);
buf = NULL;
}
return cptr;
}
/***************************************************************************
* ParseLoadOrder (internal, static)
*
* Parses the loadorder options from the configuration and puts it into
* a structure.
*/
static BOOL ParseLoadOrder(char *order, enum loadorder_type lo[])
{
static int warn;
char *cptr;
int n = 0;
cptr = get_tok(order, ", \t");
while(cptr)
{
enum loadorder_type type = LOADORDER_INVALID;
if(n >= LOADORDER_NTYPES-1)
{
ERR("More than existing %d module-types specified, rest ignored\n", LOADORDER_NTYPES-1);
break;
}
switch(*cptr)
{
case 'N': /* Native */
case 'n': type = LOADORDER_DLL; break;
case 'E': /* Elfdll */
case 'e':
if (!warn++) MESSAGE("Load order 'elfdll' no longer supported, ignored\n");
break;
case 'S': /* So */
case 's': type = LOADORDER_SO; break;
case 'B': /* Builtin */
case 'b': type = LOADORDER_BI; break;
default:
ERR("Invalid load order module-type '%s', ignored\n", cptr);
}
if(type != LOADORDER_INVALID) lo[n++] = type;
cptr = get_tok(NULL, ", \t");
}
lo[n] = LOADORDER_INVALID;
return TRUE;
}
/***************************************************************************
* AddLoadOrder (internal, static)
*
* Adds an entry in the list of command-line overrides.
*/
static BOOL AddLoadOrder(module_loadorder_t *plo)
{
int i;
/* TRACE(module, "'%s' -> %08lx\n", plo->modulename, *(DWORD *)(plo->loadorder)); */
for(i = 0; i < cmdline_list.count; i++)
{
if(!cmp_sort_func(plo, &cmdline_list.order[i] ))
{
/* replace existing option */
memcpy( cmdline_list.order[i].loadorder, plo->loadorder, sizeof(plo->loadorder));
return TRUE;
}
}
if (i >= cmdline_list.alloc)
{
/* No space in current array, make it larger */
cmdline_list.alloc += LOADORDER_ALLOC_CLUSTER;
cmdline_list.order = HeapReAlloc(GetProcessHeap(), 0, cmdline_list.order,
cmdline_list.alloc * sizeof(module_loadorder_t));
if(!cmdline_list.order)
{
MESSAGE("Virtual memory exhausted\n");
exit(1);
}
}
memcpy(cmdline_list.order[i].loadorder, plo->loadorder, sizeof(plo->loadorder));
cmdline_list.order[i].modulename = HeapAlloc(GetProcessHeap(), 0, strlen(plo->modulename)+1);
strcpy( (char *)cmdline_list.order[i].modulename, plo->modulename );
cmdline_list.count++;
return TRUE;
}
/***************************************************************************
* AddLoadOrderSet (internal, static)
*
* Adds a set of entries in the list of command-line overrides from the key parameter.
*/
static BOOL AddLoadOrderSet(char *key, char *order)
{
module_loadorder_t ldo;
char *cptr;
/* Parse the loadorder before the rest because strtok is not reentrant */
if(!ParseLoadOrder(order, ldo.loadorder))
return FALSE;
cptr = get_tok(key, ", \t");
while(cptr)
{
char *ext = strrchr(cptr, '.');
if(ext)
{
if(strlen(ext) == 4 &&
(!FILE_strcasecmp(ext, ".dll") || !FILE_strcasecmp(ext, ".exe")))
MESSAGE("Warning: Loadorder override '%s' contains an extension and might not be found during lookup\n", cptr);
}
ldo.modulename = cptr;
if(!AddLoadOrder(&ldo)) return FALSE;
cptr = get_tok(NULL, ", \t");
}
return TRUE;
}
/***************************************************************************
* MODULE_AddLoadOrderOption
*
* The commandline option is in the form:
* name[,name,...]=native[,b,...]
*/
void MODULE_AddLoadOrderOption( const char *option )
{
char *value, *key = HeapAlloc(GetProcessHeap(), 0, strlen(option)+1);
strcpy( key, option );
if (!(value = strchr(key, '='))) goto error;
*value++ = '\0';
TRACE("Commandline override '%s' = '%s'\n", key, value);
if (!AddLoadOrderSet(key, value)) goto error;
HeapFree(GetProcessHeap(), 0, key);
/* sort the array for quick lookup */
qsort(cmdline_list.order, cmdline_list.count, sizeof(cmdline_list.order[0]), cmp_sort_func);
return;
error:
MESSAGE( "Syntax: -dll name[,name[,...]]={native|so|builtin}[,{n|s|b}[,...]]\n"
" - 'name' is the name of any dll without extension\n"
" - the order of loading (native, so and builtin) can be abbreviated\n"
" with the first letter\n"
" - the option can be specified multiple times\n"
" Example:\n"
" -dll comdlg32,commdlg=n -dll shell,shell32=b\n" );
ExitProcess(1);
}
/***************************************************************************
* set_registry_keys
*
* Set individual registry keys for a multiple dll specification
* Helper for MODULE_InitLoadOrder().
*/
inline static void set_registry_keys( HKEY hkey, char *module, const char *buffer )
{
static int warn;
char *p = get_tok( module, ", \t" );
TRACE( "converting \"%s\" = \"%s\"\n", module, buffer );
if (!warn)
MESSAGE( "Warning: setting multiple modules in a single DllOverrides entry is no longer\n"
"recommended. It is suggested that you rewrite the configuration file entry:\n\n"
"\"%s\" = \"%s\"\n\n"
"into something like:\n\n", module, buffer );
while (p)
{
if (!warn) MESSAGE( "\"%s\" = \"%s\"\n", p, buffer );
/* only set it if not existing already */
if (RegQueryValueExA( hkey, p, 0, NULL, NULL, NULL ) == ERROR_FILE_NOT_FOUND)
RegSetValueExA( hkey, p, 0, REG_SZ, buffer, strlen(buffer)+1 );
p = get_tok( NULL, ", \t" );
}
if (!warn) MESSAGE( "\n" );
warn = 1;
}
/***************************************************************************
* MODULE_InitLoadOrder
*
* Convert entries containing multiple dll names (old syntax) to the
* new one dll module per entry syntax
*/
void MODULE_InitLoadOrder(void)
{
char module[80];
char buffer[1024];
char *p;
HKEY hkey;
DWORD index = 0;
if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\DllOverrides", &hkey ))
return;
for (;;)
{
DWORD type, count = sizeof(buffer), name_len = sizeof(module);
if (RegEnumValueA( hkey, index, module, &name_len, NULL, &type, buffer, &count )) break;
p = module;
while (isspace(*p)) p++;
p += strcspn( p, ", \t" );
while (isspace(*p)) p++;
if (*p)
{
RegDeleteValueA( hkey, module );
set_registry_keys( hkey, module, buffer );
}
else index++;
}
RegCloseKey( hkey );
}
/***************************************************************************
* get_list_load_order
*
* Get the load order for a given module from the command-line or
* default lists.
*/
static BOOL get_list_load_order( const char *module, const struct loadorder_list *list,
enum loadorder_type lo[] )
{
module_loadorder_t tmp, *res = NULL;
tmp.modulename = module;
/* some bsearch implementations (Solaris) are buggy when the number of items is 0 */
if (list->count && (res = bsearch(&tmp, list->order, list->count, sizeof(list->order[0]), cmp_sort_func)))
memcpy( lo, res->loadorder, sizeof(res->loadorder) );
return (res != NULL);
}
/***************************************************************************
* get_app_load_order
*
* Get the load order for a given module from the app-specific DllOverrides list.
* Also look for default '*' key if no module key found.
*/
static BOOL get_app_load_order( const char *module, enum loadorder_type lo[], BOOL *got_default )
{
HKEY hkey, appkey;
DWORD count, type, res;
char buffer[MAX_PATH+16], *appname, *p;
if (!GetModuleFileName16( GetCurrentTask(), buffer, MAX_PATH ) &&
!GetModuleFileNameA( 0, buffer, MAX_PATH ))
{
WARN( "could not get module file name loading %s\n", module );
return FALSE;
}
appname = buffer;
if ((p = strrchr( appname, '/' ))) appname = p + 1;
if ((p = strrchr( appname, '\\' ))) appname = p + 1;
TRACE( "searching '%s' in AppDefaults\\%s\\DllOverrides\n", module, appname );
if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\AppDefaults", &hkey ))
return FALSE;
/* open AppDefaults\\appname\\DllOverrides key */
strcat( appname, "\\DllOverrides" );
res = RegOpenKeyA( hkey, appname, &appkey );
RegCloseKey( hkey );
if (res) return FALSE;
count = sizeof(buffer);
if ((res = RegQueryValueExA( appkey, module, NULL, &type, buffer, &count )))
{
if (!(res = RegQueryValueExA( appkey, "*", NULL, &type, buffer, &count )))
*got_default = TRUE;
}
else TRACE( "got app loadorder '%s' for '%s'\n", buffer, module );
RegCloseKey( appkey );
if (res) return FALSE;
return ParseLoadOrder( buffer, lo );
}
/***************************************************************************
* get_standard_load_order
*
* Get the load order for a given module from the main DllOverrides list
* Also look for default '*' key if no module key found.
*/
static BOOL get_standard_load_order( const char *module, enum loadorder_type lo[],
BOOL *got_default )
{
HKEY hkey;
DWORD count, type, res;
char buffer[80];
if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\DllOverrides", &hkey ))
return FALSE;
count = sizeof(buffer);
if ((res = RegQueryValueExA( hkey, module, NULL, &type, buffer, &count )))
{
if (!(res = RegQueryValueExA( hkey, "*", NULL, &type, buffer, &count )))
*got_default = TRUE;
}
else TRACE( "got standard loadorder '%s' for '%s'\n", buffer, module );
RegCloseKey( hkey );
if (res) return FALSE;
return ParseLoadOrder( buffer, lo );
}
/***************************************************************************
* get_default_load_order
*
* Get the default load order if nothing specified for a given dll.
*/
static void get_default_load_order( enum loadorder_type lo[] )
{
DWORD res;
static enum loadorder_type default_loadorder[LOADORDER_NTYPES];
static int loaded;
if (!loaded)
{
char buffer[80];
HKEY hkey;
if (!(res = RegOpenKeyA( HKEY_LOCAL_MACHINE,
"Software\\Wine\\Wine\\Config\\DllDefaults", &hkey )))
{
DWORD type, count = sizeof(buffer);
res = RegQueryValueExA( hkey, "DefaultLoadOrder", NULL, &type, buffer, &count );
RegCloseKey( hkey );
}
if (res) strcpy( buffer, "n,b,s" );
ParseLoadOrder( buffer, default_loadorder );
loaded = 1;
TRACE( "got default loadorder '%s'\n", buffer );
}
memcpy( lo, default_loadorder, sizeof(default_loadorder) );
}
/***************************************************************************
* MODULE_GetLoadOrder (internal)
*
* Locate the loadorder of a module.
* Any path is stripped from the path-argument and so are the extension
* '.dll' and '.exe'. A lookup in the table can yield an override for
* the specific dll. Otherwise the default load order is returned.
*/
void MODULE_GetLoadOrder( enum loadorder_type loadorder[], const char *path, BOOL win32 )
{
char fname[256];
char sysdir[MAX_PATH+1];
char *cptr;
char *name;
int len;
BOOL got_app_default = FALSE, got_std_default = FALSE;
enum loadorder_type lo_default[LOADORDER_NTYPES];
TRACE("looking for %s\n", path);
if ( ! GetSystemDirectoryA ( sysdir, MAX_PATH ) ) goto done;
/* Strip path information for 16 bit modules or if the module
resides in the system directory */
if ( !win32 || !FILE_strncasecmp ( sysdir, path, strlen (sysdir) ) )
{
cptr = strrchr(path, '\\');
if(!cptr)
name = strrchr(path, '/');
else
name = strrchr(cptr, '/');
if(!name)
name = cptr ? cptr+1 : (char *)path;
else
name++;
if((cptr = strchr(name, ':')) != NULL) /* Also strip drive if in format 'C:MODULE.DLL' */
name = cptr+1;
}
else
name = (char *)path;
len = strlen(name);
if(len >= sizeof(fname) || len <= 0)
{
WARN("Path '%s' -> '%s' reduces to zilch or just too large...\n", path, name);
goto done;
}
strcpy(fname, name);
if(len >= 4 && (!FILE_strcasecmp(fname+len-4, ".dll") || !FILE_strcasecmp(fname+len-4, ".exe")))
fname[len-4] = '\0';
/* check command-line first */
if (get_list_load_order( fname, &cmdline_list, loadorder )) return;
/* then app-specific config */
if (get_app_load_order( fname, loadorder, &got_app_default ))
{
if (!got_app_default) return;
/* save the default value for later on */
memcpy( lo_default, loadorder, sizeof(lo_default) );
}
/* then standard config */
if (get_standard_load_order( fname, loadorder, &got_std_default ))
{
if (!got_std_default) return;
/* save the default value for later on */
if (!got_app_default) memcpy( lo_default, loadorder, sizeof(lo_default) );
}
/* then compiled-in defaults */
if (get_list_load_order( fname, &default_list, loadorder )) return;
done:
/* last, return the default */
if (got_app_default || got_std_default)
memcpy( loadorder, lo_default, sizeof(lo_default) );
else
get_default_load_order( loadorder );
}
Reference in New Issue View Git Blame Copy Permalink