2 * Module/Library loadorder
4 * Copyright 1999 Bertho Stultiens
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(module);
36 #define LOADORDER_ALLOC_CLUSTER 32 /* Allocate with 32 entries at a time */
38 typedef struct module_loadorder
40 const char *modulename;
41 enum loadorder_type loadorder[LOADORDER_NTYPES];
48 module_loadorder_t *order;
51 /* default load-order if nothing specified */
52 /* the list must remain sorted by dll name */
53 static module_loadorder_t default_order_list[] =
55 { "display", { LOADORDER_BI, 0, 0, 0 } },
56 { "gdi.exe", { LOADORDER_BI, 0, 0, 0 } },
57 { "gdi32", { LOADORDER_BI, 0, 0, 0 } },
58 { "glide2x", { LOADORDER_SO, LOADORDER_DLL, 0, 0 } },
59 { "glide3x", { LOADORDER_SO, LOADORDER_DLL, 0, 0 } },
60 { "icmp", { LOADORDER_BI, 0, 0, 0 } },
61 { "kernel", { LOADORDER_BI, 0, 0, 0 } },
62 { "kernel32", { LOADORDER_BI, 0, 0, 0 } },
63 { "keyboard", { LOADORDER_BI, 0, 0, 0 } },
64 { "krnl386.exe", { LOADORDER_BI, 0, 0, 0 } },
65 { "mmsystem", { LOADORDER_BI, 0, 0, 0 } },
66 { "mouse", { LOADORDER_BI, 0, 0, 0 } },
67 { "ntdll", { LOADORDER_BI, 0, 0, 0 } },
68 { "odbc32", { LOADORDER_BI, 0, 0, 0 } },
69 { "system", { LOADORDER_BI, 0, 0, 0 } },
70 { "toolhelp", { LOADORDER_BI, 0, 0, 0 } },
71 { "ttydrv", { LOADORDER_BI, 0, 0, 0 } },
72 { "user.exe", { LOADORDER_BI, 0, 0, 0 } },
73 { "user32", { LOADORDER_BI, 0, 0, 0 } },
74 { "w32skrnl", { LOADORDER_BI, 0, 0, 0 } },
75 { "winaspi", { LOADORDER_BI, 0, 0, 0 } },
76 { "windebug", { LOADORDER_DLL, LOADORDER_BI, 0, 0 } },
77 { "winedos", { LOADORDER_BI, 0, 0, 0 } },
78 { "wineps", { LOADORDER_BI, 0, 0, 0 } },
79 { "wing", { LOADORDER_BI, 0, 0, 0 } },
80 { "winmm", { LOADORDER_BI, 0, 0, 0 } },
81 { "winsock", { LOADORDER_BI, 0, 0, 0 } },
82 { "wnaspi32", { LOADORDER_BI, 0, 0, 0 } },
83 { "wow32", { LOADORDER_BI, 0, 0, 0 } },
84 { "wprocs", { LOADORDER_BI, 0, 0, 0 } },
85 { "ws2_32", { LOADORDER_BI, 0, 0, 0 } },
86 { "wsock32", { LOADORDER_BI, 0, 0, 0 } },
87 { "x11drv", { LOADORDER_BI, 0, 0, 0 } }
90 static const struct loadorder_list default_list =
92 sizeof(default_order_list)/sizeof(default_order_list[0]),
93 sizeof(default_order_list)/sizeof(default_order_list[0]),
97 /* default if nothing else specified */
98 static const enum loadorder_type default_loadorder[LOADORDER_NTYPES] =
100 LOADORDER_DLL, LOADORDER_BI, 0, 0
103 static struct loadorder_list cmdline_list;
106 /***************************************************************************
107 * cmp_sort_func (internal, static)
109 * Sorting and comparing function used in sort and search of loadorder
112 static int cmp_sort_func(const void *s1, const void *s2)
114 return FILE_strcasecmp(((module_loadorder_t *)s1)->modulename,
115 ((module_loadorder_t *)s2)->modulename);
119 /***************************************************************************
120 * get_tok (internal, static)
122 * strtok wrapper for non-destructive buffer writing.
123 * NOTE: strtok is not reentrant and therefore this code is neither.
125 static char *get_tok(const char *str, const char *delim)
127 static char *buf = NULL;
135 HeapFree(GetProcessHeap(), 0, buf);
141 buf = HeapAlloc(GetProcessHeap(), 0, strlen(str)+1);
143 cptr = strtok(buf, delim);
147 cptr = strtok(NULL, delim);
152 HeapFree(GetProcessHeap(), 0, buf);
159 /***************************************************************************
162 * Return the base name of a file name (i.e. remove the path components).
164 static const char *get_basename( const char *name )
168 if (name[0] && name[1] == ':') name += 2; /* strip drive specification */
169 if ((ptr = strrchr( name, '\\' ))) name = ptr + 1;
170 if ((ptr = strrchr( name, '/' ))) name = ptr + 1;
175 /***************************************************************************
178 * Return a loadorder in printable form.
180 static const char *debugstr_loadorder( enum loadorder_type lo[] )
183 char buffer[LOADORDER_NTYPES*3+1];
186 for(i = 0; i < LOADORDER_NTYPES; i++)
188 if (lo[i] == LOADORDER_INVALID) break;
191 case LOADORDER_DLL: strcat( buffer, "n," ); break;
192 case LOADORDER_SO: strcat( buffer, "s," ); break;
193 case LOADORDER_BI: strcat( buffer, "b," ); break;
194 default: strcat( buffer, "?," ); break;
197 if (buffer[0]) buffer[strlen(buffer)-1] = 0;
198 return debugstr_a(buffer);
202 /***************************************************************************
203 * ParseLoadOrder (internal, static)
205 * Parses the loadorder options from the configuration and puts it into
208 static BOOL ParseLoadOrder(char *order, enum loadorder_type lo[])
214 cptr = get_tok(order, ", \t");
217 enum loadorder_type type = LOADORDER_INVALID;
219 if(n >= LOADORDER_NTYPES-1)
221 ERR("More than existing %d module-types specified, rest ignored\n", LOADORDER_NTYPES-1);
227 case 'N': /* Native */
228 case 'n': type = LOADORDER_DLL; break;
230 case 'E': /* Elfdll */
232 if (!warn++) MESSAGE("Load order 'elfdll' no longer supported, ignored\n");
235 case 's': type = LOADORDER_SO; break;
237 case 'B': /* Builtin */
238 case 'b': type = LOADORDER_BI; break;
241 ERR("Invalid load order module-type '%s', ignored\n", cptr);
244 if(type != LOADORDER_INVALID) lo[n++] = type;
245 cptr = get_tok(NULL, ", \t");
247 lo[n] = LOADORDER_INVALID;
252 /***************************************************************************
253 * AddLoadOrder (internal, static)
255 * Adds an entry in the list of command-line overrides.
257 static BOOL AddLoadOrder(module_loadorder_t *plo)
261 /* TRACE(module, "'%s' -> %08lx\n", plo->modulename, *(DWORD *)(plo->loadorder)); */
263 for(i = 0; i < cmdline_list.count; i++)
265 if(!cmp_sort_func(plo, &cmdline_list.order[i] ))
267 /* replace existing option */
268 memcpy( cmdline_list.order[i].loadorder, plo->loadorder, sizeof(plo->loadorder));
273 if (i >= cmdline_list.alloc)
275 /* No space in current array, make it larger */
276 cmdline_list.alloc += LOADORDER_ALLOC_CLUSTER;
277 cmdline_list.order = HeapReAlloc(GetProcessHeap(), 0, cmdline_list.order,
278 cmdline_list.alloc * sizeof(module_loadorder_t));
279 if(!cmdline_list.order)
281 MESSAGE("Virtual memory exhausted\n");
285 memcpy(cmdline_list.order[i].loadorder, plo->loadorder, sizeof(plo->loadorder));
286 cmdline_list.order[i].modulename = HeapAlloc(GetProcessHeap(), 0, strlen(plo->modulename)+1);
287 strcpy( (char *)cmdline_list.order[i].modulename, plo->modulename );
288 cmdline_list.count++;
293 /***************************************************************************
294 * AddLoadOrderSet (internal, static)
296 * Adds a set of entries in the list of command-line overrides from the key parameter.
298 static BOOL AddLoadOrderSet(char *key, char *order)
300 module_loadorder_t ldo;
303 /* Parse the loadorder before the rest because strtok is not reentrant */
304 if(!ParseLoadOrder(order, ldo.loadorder))
307 cptr = get_tok(key, ", \t");
310 char *ext = strrchr(cptr, '.');
311 if(ext && !FILE_strcasecmp( ext, ".dll" )) *ext = 0;
312 ldo.modulename = cptr;
313 if(!AddLoadOrder(&ldo)) return FALSE;
314 cptr = get_tok(NULL, ", \t");
320 /***************************************************************************
321 * MODULE_AddLoadOrderOption
323 * The commandline option is in the form:
324 * name[,name,...]=native[,b,...]
326 void MODULE_AddLoadOrderOption( const char *option )
328 char *value, *key = HeapAlloc(GetProcessHeap(), 0, strlen(option)+1);
330 strcpy( key, option );
331 if (!(value = strchr(key, '='))) goto error;
334 TRACE("Commandline override '%s' = '%s'\n", key, value);
336 if (!AddLoadOrderSet(key, value)) goto error;
337 HeapFree(GetProcessHeap(), 0, key);
339 /* sort the array for quick lookup */
340 qsort(cmdline_list.order, cmdline_list.count, sizeof(cmdline_list.order[0]), cmp_sort_func);
344 MESSAGE( "Syntax: -dll name[,name[,...]]={native|so|builtin}[,{n|s|b}[,...]]\n"
345 " - 'name' is the name of any dll without extension\n"
346 " - the order of loading (native, so and builtin) can be abbreviated\n"
347 " with the first letter\n"
348 " - the option can be specified multiple times\n"
350 " -dll comdlg32,commdlg=n -dll shell,shell32=b\n" );
355 /***************************************************************************
356 * get_list_load_order
358 * Get the load order for a given module from the command-line or
361 static BOOL get_list_load_order( const char *module, const struct loadorder_list *list,
362 enum loadorder_type lo[] )
364 module_loadorder_t tmp, *res = NULL;
366 tmp.modulename = module;
367 /* some bsearch implementations (Solaris) are buggy when the number of items is 0 */
368 if (list->count && (res = bsearch(&tmp, list->order, list->count, sizeof(list->order[0]), cmp_sort_func)))
369 memcpy( lo, res->loadorder, sizeof(res->loadorder) );
370 return (res != NULL);
374 /***************************************************************************
377 * Open the registry key to the app-specific DllOverrides list.
379 static HKEY open_app_key( const char *module )
382 char buffer[MAX_PATH+16], *appname;
384 if (!GetModuleFileNameA( 0, buffer, MAX_PATH ))
386 WARN( "could not get module file name loading %s\n", module );
389 appname = (char *)get_basename( buffer );
391 TRACE( "searching '%s' in AppDefaults\\%s\\DllOverrides\n", module, appname );
393 if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\AppDefaults", &hkey ))
396 /* open AppDefaults\\appname\\DllOverrides key */
397 strcat( appname, "\\DllOverrides" );
398 if (RegOpenKeyA( hkey, appname, &appkey )) appkey = 0;
404 /***************************************************************************
407 * Load the registry loadorder value for a given module.
409 static BOOL get_registry_value( HKEY hkey, const char *module, enum loadorder_type lo[] )
414 count = sizeof(buffer);
415 if (RegQueryValueExA( hkey, module, NULL, &type, buffer, &count )) return FALSE;
416 return ParseLoadOrder( buffer, lo );
420 /***************************************************************************
421 * MODULE_GetBuiltinPath
423 * Get the path of a builtin module when the native file does not exist.
425 BOOL MODULE_GetBuiltinPath( const char *libname, const char *ext, char *filename, UINT size )
429 UINT len = GetSystemDirectoryA( filename, size );
431 if (FILE_contains_path( libname ))
435 /* if the library name contains a path and can not be found,
437 * exception: if the path is the system directory, proceed,
438 * so that modules which are not PE modules can be loaded.
439 * If the library name does not contain a path and can not
440 * be found, assume the system directory is meant */
442 if (strlen(libname) >= size) return FALSE; /* too long */
443 if (strchr( libname, '/' )) /* need to convert slashes */
445 if (!(tmp = HeapAlloc( GetProcessHeap(), 0, strlen(libname)+1 ))) return FALSE;
446 strcpy( tmp, libname );
447 for (p = tmp; *p; p++) if (*p == '/') *p = '\\';
449 else tmp = (char *)libname;
451 if (!FILE_strncasecmp( filename, tmp, len ) && tmp[len] == '\\')
453 strcpy( filename, tmp );
456 if (tmp != libname) HeapFree( GetProcessHeap(), 0, tmp );
457 if (!ret) return FALSE;
461 if (strlen(libname) >= size - len - 1) return FALSE;
462 filename[len] = '\\';
463 strcpy( filename+len+1, libname );
466 /* if the filename doesn't have an extension, append the default */
467 if (!(p = strrchr( filename, '.')) || strchr( p, '/' ) || strchr( p, '\\'))
469 if (strlen(filename) + strlen(ext) >= size) return FALSE;
470 strcat( filename, ext );
476 /***************************************************************************
477 * MODULE_GetLoadOrder (internal)
479 * Locate the loadorder of a module.
480 * Any path is stripped from the path-argument and so are the extension
481 * '.dll' and '.exe'. A lookup in the table can yield an override for
482 * the specific dll. Otherwise the default load order is returned.
484 void MODULE_GetLoadOrder( enum loadorder_type loadorder[], const char *path, BOOL win32 )
486 static HKEY std_key = (HKEY)-1; /* key to standard section, cached */
488 char *module, *basename;
491 TRACE("looking for %s\n", path);
493 loadorder[0] = LOADORDER_INVALID; /* in case something bad happens below */
495 /* Strip path information for 16 bit modules or if the module
496 * resides in the system directory */
499 path = get_basename( path );
500 if (BUILTIN_IsPresent(path))
502 TRACE( "forcing loadorder to builtin for %s\n", debugstr_a(path) );
503 /* force builtin loadorder since the dll is already in memory */
504 loadorder[0] = LOADORDER_BI;
505 loadorder[1] = LOADORDER_INVALID;
511 char sysdir[MAX_PATH+1];
512 if (!GetSystemDirectoryA( sysdir, MAX_PATH )) return;
513 if (!FILE_strncasecmp( sysdir, path, strlen (sysdir) ))
515 path += strlen(sysdir);
516 while (*path == '\\' || *path == '/') path++;
520 if (!(len = strlen(path))) return;
521 if (!(module = HeapAlloc( GetProcessHeap(), 0, len + 2 ))) return;
522 strcpy( module+1, path ); /* reserve module[0] for the wildcard char */
526 char *ext = module + 1 + len - 4;
527 if (!FILE_strcasecmp( ext, ".dll" )) *ext = 0;
530 /* check command-line first */
531 if (get_list_load_order( module+1, &cmdline_list, loadorder ))
533 TRACE( "got cmdline %s for %s\n",
534 debugstr_loadorder(loadorder), debugstr_a(path) );
538 /* then explicit module name in AppDefaults */
539 app_key = open_app_key( module+1 );
540 if (app_key && get_registry_value( app_key, module+1, loadorder ))
542 TRACE( "got app defaults %s for %s\n",
543 debugstr_loadorder(loadorder), debugstr_a(path) );
547 /* then explicit module name in standard section */
548 if (std_key == (HKEY)-1)
549 RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\DllOverrides", &std_key );
551 if (std_key && get_registry_value( std_key, module+1, loadorder ))
553 TRACE( "got standard entry %s for %s\n",
554 debugstr_loadorder(loadorder), debugstr_a(path) );
558 /* then module basename preceded by '*' in AppDefaults */
559 basename = (char *)get_basename( module+1 );
561 if (app_key && get_registry_value( app_key, basename-1, loadorder ))
563 TRACE( "got app defaults basename %s for %s\n",
564 debugstr_loadorder(loadorder), debugstr_a(path) );
568 /* then module name preceded by '*' in standard section */
569 if (std_key && get_registry_value( std_key, basename-1, loadorder ))
571 TRACE( "got standard base name %s for %s\n",
572 debugstr_loadorder(loadorder), debugstr_a(path) );
576 /* then base name matching compiled-in defaults */
577 if (get_list_load_order( basename, &default_list, loadorder ))
579 TRACE( "got compiled-in default %s for %s\n",
580 debugstr_loadorder(loadorder), debugstr_a(path) );
584 if (basename == module+1)
586 /* then wildcard entry in AppDefaults (only if no explicit path) */
587 if (app_key && get_registry_value( app_key, "*", loadorder ))
589 TRACE( "got app defaults wildcard %s for %s\n",
590 debugstr_loadorder(loadorder), debugstr_a(path) );
594 /* then wildcard entry in standard section (only if no explicit path) */
595 if (std_key && get_registry_value( std_key, "*", loadorder ))
597 TRACE( "got standard wildcard %s for %s\n",
598 debugstr_loadorder(loadorder), debugstr_a(path) );
603 /* and last the hard-coded default */
604 memcpy( loadorder, default_loadorder, sizeof(default_loadorder) );
605 TRACE( "got hardcoded default %s for %s\n",
606 debugstr_loadorder(loadorder), debugstr_a(path) );
610 if (app_key) RegCloseKey( app_key );
611 HeapFree( GetProcessHeap(), 0, module );