/* * Dlls load order support * * Copyright 1999 Bertho Stultiens * Copyright 2003 Alexandre Julliard * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include <stdarg.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include "windef.h" #include "winternl.h" #include "ntdll_misc.h" #include "wine/debug.h" #include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(module); #define LOADORDER_ALLOC_CLUSTER 32 /* Allocate with 32 entries at a time */ typedef struct module_loadorder { const WCHAR *modulename; enum loadorder loadorder; } module_loadorder_t; struct loadorder_list { int count; int alloc; module_loadorder_t *order; }; static const WCHAR separatorsW[] = {',',' ','\t',0}; static int init_done; static struct loadorder_list env_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 strcmpiW(((const module_loadorder_t *)s1)->modulename, ((const module_loadorder_t *)s2)->modulename); } /*************************************************************************** * get_basename * * Return the base name of a file name (i.e. remove the path components). */ static const WCHAR *get_basename( const WCHAR *name ) { const WCHAR *ptr; if (name[0] && name[1] == ':') name += 2; /* strip drive specification */ if ((ptr = strrchrW( name, '\\' ))) name = ptr + 1; if ((ptr = strrchrW( name, '/' ))) name = ptr + 1; return name; } /*************************************************************************** * remove_dll_ext * * Remove extension if it is ".dll". */ static inline void remove_dll_ext( WCHAR *ext ) { if (ext[0] == '.' && toupperW(ext[1]) == 'D' && toupperW(ext[2]) == 'L' && toupperW(ext[3]) == 'L' && !ext[4]) ext[0] = 0; } /*************************************************************************** * debugstr_loadorder * * Return a loadorder in printable form. */ static const char *debugstr_loadorder( enum loadorder lo ) { switch(lo) { case LO_DISABLED: return ""; case LO_NATIVE: return "n"; case LO_BUILTIN: return "b"; case LO_NATIVE_BUILTIN: return "n,b"; case LO_BUILTIN_NATIVE: return "b,n"; case LO_DEFAULT: return "default"; default: return "??"; } } /*************************************************************************** * parse_load_order * * Parses the loadorder options from the configuration and puts it into * a structure. */ static enum loadorder parse_load_order( const WCHAR *order ) { enum loadorder ret = LO_DISABLED; while (*order) { order += strspnW( order, separatorsW ); switch(*order) { case 'N': /* native */ case 'n': if (ret == LO_DISABLED) ret = LO_NATIVE; else if (ret == LO_BUILTIN) return LO_BUILTIN_NATIVE; break; case 'B': /* builtin */ case 'b': if (ret == LO_DISABLED) ret = LO_BUILTIN; else if (ret == LO_NATIVE) return LO_NATIVE_BUILTIN; break; } order += strcspnW( order, separatorsW ); } return ret; } /*************************************************************************** * add_load_order * * Adds an entry in the list of environment overrides. */ static void add_load_order( const module_loadorder_t *plo ) { int i; for(i = 0; i < env_list.count; i++) { if(!cmp_sort_func(plo, &env_list.order[i] )) { /* replace existing option */ env_list.order[i].loadorder = plo->loadorder; return; } } if (i >= env_list.alloc) { /* No space in current array, make it larger */ env_list.alloc += LOADORDER_ALLOC_CLUSTER; if (env_list.order) env_list.order = RtlReAllocateHeap(GetProcessHeap(), 0, env_list.order, env_list.alloc * sizeof(module_loadorder_t)); else env_list.order = RtlAllocateHeap(GetProcessHeap(), 0, env_list.alloc * sizeof(module_loadorder_t)); if(!env_list.order) { MESSAGE("Virtual memory exhausted\n"); exit(1); } } env_list.order[i].loadorder = plo->loadorder; env_list.order[i].modulename = plo->modulename; env_list.count++; } /*************************************************************************** * add_load_order_set * * Adds a set of entries in the list of command-line overrides from the key parameter. */ static void add_load_order_set( WCHAR *entry ) { module_loadorder_t ldo; WCHAR *end = strchrW( entry, '=' ); if (!end) return; *end++ = 0; ldo.loadorder = parse_load_order( end ); while (*entry) { entry += strspnW( entry, separatorsW ); end = entry + strcspnW( entry, separatorsW ); if (*end) *end++ = 0; if (*entry) { WCHAR *ext = strrchrW(entry, '.'); if (ext) remove_dll_ext( ext ); ldo.modulename = entry; add_load_order( &ldo ); entry = end; } } } /*************************************************************************** * init_load_order */ static void init_load_order(void) { const char *order = getenv( "WINEDLLOVERRIDES" ); UNICODE_STRING strW; WCHAR *entry, *next; init_done = 1; if (!order) return; if (!strcmp( order, "help" )) { MESSAGE( "Syntax:\n" " WINEDLLOVERRIDES=\"entry;entry;entry...\"\n" " where each entry is of the form:\n" " module[,module...]={native|builtin}[,{b|n}]\n" "\n" " Only the first letter of the override (native or builtin)\n" " is significant.\n\n" "Example:\n" " WINEDLLOVERRIDES=\"comdlg32=n,b;shell32,shlwapi=b\"\n" ); exit(0); } RtlCreateUnicodeStringFromAsciiz( &strW, order ); entry = strW.Buffer; while (*entry) { while (*entry && *entry == ';') entry++; if (!*entry) break; next = strchrW( entry, ';' ); if (next) *next++ = 0; else next = entry + strlenW(entry); add_load_order_set( entry ); entry = next; } /* sort the array for quick lookup */ if (env_list.count) qsort(env_list.order, env_list.count, sizeof(env_list.order[0]), cmp_sort_func); /* Note: we don't free the Unicode string because the * stored module names point inside it */ } /*************************************************************************** * get_env_load_order * * Get the load order for a given module from the WINEDLLOVERRIDES environment variable. */ static inline enum loadorder get_env_load_order( const WCHAR *module ) { module_loadorder_t tmp, *res; tmp.modulename = module; /* some bsearch implementations (Solaris) are buggy when the number of items is 0 */ if (env_list.count && (res = bsearch(&tmp, env_list.order, env_list.count, sizeof(env_list.order[0]), cmp_sort_func))) return res->loadorder; return LO_INVALID; } /*************************************************************************** * get_standard_key * * Return a handle to the standard DllOverrides registry section. */ static HANDLE get_standard_key(void) { static const WCHAR DllOverridesW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\', 'D','l','l','O','v','e','r','r','i','d','e','s',0}; static HANDLE std_key = (HANDLE)-1; if (std_key == (HANDLE)-1) { OBJECT_ATTRIBUTES attr; UNICODE_STRING nameW; HANDLE root; RtlOpenCurrentUser( KEY_ALL_ACCESS, &root ); attr.Length = sizeof(attr); attr.RootDirectory = root; attr.ObjectName = &nameW; attr.Attributes = 0; attr.SecurityDescriptor = NULL; attr.SecurityQualityOfService = NULL; RtlInitUnicodeString( &nameW, DllOverridesW ); /* @@ Wine registry key: HKCU\Software\Wine\DllOverrides */ if (NtOpenKey( &std_key, KEY_ALL_ACCESS, &attr )) std_key = 0; NtClose( root ); } return std_key; } /*************************************************************************** * get_app_key * * Get the registry key for the app-specific DllOverrides list. */ static HANDLE get_app_key( const WCHAR *app_name ) { OBJECT_ATTRIBUTES attr; UNICODE_STRING nameW; HANDLE root; WCHAR *str; static const WCHAR AppDefaultsW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\', 'A','p','p','D','e','f','a','u','l','t','s','\\',0}; static const WCHAR DllOverridesW[] = {'\\','D','l','l','O','v','e','r','r','i','d','e','s',0}; static HANDLE app_key = (HANDLE)-1; if (app_key != (HANDLE)-1) return app_key; str = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(AppDefaultsW) + sizeof(DllOverridesW) + strlenW(app_name) * sizeof(WCHAR) ); if (!str) return 0; strcpyW( str, AppDefaultsW ); strcatW( str, app_name ); strcatW( str, DllOverridesW ); RtlOpenCurrentUser( KEY_ALL_ACCESS, &root ); attr.Length = sizeof(attr); attr.RootDirectory = root; attr.ObjectName = &nameW; attr.Attributes = 0; attr.SecurityDescriptor = NULL; attr.SecurityQualityOfService = NULL; RtlInitUnicodeString( &nameW, str ); /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\DllOverrides */ if (NtOpenKey( &app_key, KEY_ALL_ACCESS, &attr )) app_key = 0; NtClose( root ); RtlFreeHeap( GetProcessHeap(), 0, str ); return app_key; } /*************************************************************************** * get_registry_value * * Load the registry loadorder value for a given module. */ static enum loadorder get_registry_value( HANDLE hkey, const WCHAR *module ) { UNICODE_STRING valueW; char buffer[80]; DWORD count; RtlInitUnicodeString( &valueW, module ); if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, buffer, sizeof(buffer), &count )) { WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)buffer)->Data; return parse_load_order( str ); } return LO_INVALID; } /*************************************************************************** * get_load_order_value * * Get the load order for the exact specified module string, looking in: * 1. The WINEDLLOVERRIDES environment variable * 2. The per-application DllOverrides key * 3. The standard DllOverrides key */ static enum loadorder get_load_order_value( HANDLE std_key, HANDLE app_key, const WCHAR *module ) { enum loadorder ret; if ((ret = get_env_load_order( module )) != LO_INVALID) { TRACE( "got environment %s for %s\n", debugstr_loadorder(ret), debugstr_w(module) ); return ret; } if (app_key && ((ret = get_registry_value( app_key, module )) != LO_INVALID)) { TRACE( "got app defaults %s for %s\n", debugstr_loadorder(ret), debugstr_w(module) ); return ret; } if (std_key && ((ret = get_registry_value( std_key, module )) != LO_INVALID)) { TRACE( "got standard key %s for %s\n", debugstr_loadorder(ret), debugstr_w(module) ); return ret; } return ret; } /*************************************************************************** * get_load_order (internal) * * Return the loadorder of a module. * The system directory and '.dll' extension is stripped from the path. */ enum loadorder get_load_order( const WCHAR *app_name, const WCHAR *path ) { enum loadorder ret = LO_INVALID; HANDLE std_key, app_key = 0; WCHAR *module, *basename; UNICODE_STRING path_str; int len; if (!init_done) init_load_order(); std_key = get_standard_key(); if (app_name) app_key = get_app_key( app_name ); TRACE("looking for %s\n", debugstr_w(path)); /* Strip path information if the module resides in the system directory */ RtlInitUnicodeString( &path_str, path ); if (RtlPrefixUnicodeString( &system_dir, &path_str, TRUE )) { const WCHAR *p = path + system_dir.Length / sizeof(WCHAR); while (*p == '\\' || *p == '/') p++; if (!strchrW( p, '\\' ) && !strchrW( p, '/' )) path = p; } if (!(len = strlenW(path))) return ret; if (!(module = RtlAllocateHeap( GetProcessHeap(), 0, (len + 2) * sizeof(WCHAR) ))) return ret; strcpyW( module+1, path ); /* reserve module[0] for the wildcard char */ basename = (WCHAR *)get_basename( module+1 ); if (len >= 4) remove_dll_ext( module + 1 + len - 4 ); /* first explicit module name */ if ((ret = get_load_order_value( std_key, app_key, module+1 )) != LO_INVALID) goto done; /* then module basename preceded by '*' */ basename[-1] = '*'; if ((ret = get_load_order_value( std_key, app_key, basename-1 )) != LO_INVALID) goto done; /* then module basename without '*' (only if explicit path) */ if (basename != module+1 && ((ret = get_load_order_value( std_key, app_key, basename )) != LO_INVALID)) goto done; /* if loading the main exe with an explicit path, try native first */ if (!app_name && basename != module+1) { ret = LO_NATIVE_BUILTIN; TRACE( "got main exe default %s for %s\n", debugstr_loadorder(ret), debugstr_w(path) ); goto done; } /* and last the hard-coded default */ ret = LO_DEFAULT; TRACE( "got hardcoded %s for %s\n", debugstr_loadorder(ret), debugstr_w(path) ); done: RtlFreeHeap( GetProcessHeap(), 0, module ); return ret; }