dlls/ntdll/loadorder.c

   1 /*
   2  * Dlls load order support
   3  *
   4  * Copyright 1999 Bertho Stultiens
   5  * Copyright 2003 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <assert.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "winreg.h"
  34 #include "winternl.h"
  35 #include "file.h"
  36 #include "module.h"
  37 #include "ntdll_misc.h"
  38
  39 #include "wine/debug.h"
  40 #include "wine/unicode.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(module);
  43
  44 #define LOADORDER_ALLOC_CLUSTER 32      /* Allocate with 32 entries at a time */
  45
  46 typedef struct module_loadorder
  47 {
  48     const WCHAR        *modulename;
  49     enum loadorder_type loadorder[LOADORDER_NTYPES];
  50 } module_loadorder_t;
  51
  52 struct loadorder_list
  53 {
  54     int                 count;
  55     int                 alloc;
  56     module_loadorder_t *order;
  57 };
  58
  59 /* dll to load as builtins if not explicitly specified otherwise */
  60 /* the list must remain sorted by dll name */
  61 static const WCHAR default_builtins[][16] =
  62 {
  63     { 'g','d','i','3','2',0 },
  64     { 'i','c','m','p',0 },
  65     { 'k','e','r','n','e','l','3','2',0 },
  66     { 'm','m','s','y','s','t','e','m',0 },
  67     { 'n','t','d','l','l',0 },
  68     { 'o','d','b','c','3','2',0 },
  69     { 's','o','u','n','d',0 },
  70     { 't','t','y','d','r','v',0 },
  71     { 'u','s','e','r','3','2',0 },
  72     { 'w','3','2','s','k','r','n','l',0 },
  73     { 'w','3','2','s','y','s',0 },
  74     { 'w','i','n','3','2','s','1','6',0 },
  75     { 'w','i','n','a','s','p','i',0 },
  76     { 'w','i','n','e','d','o','s',0 },
  77     { 'w','i','n','e','p','s','1','6','.','d','r','v',0 },
  78     { 'w','i','n','e','p','s',0 },
  79     { 'w','i','n','m','m',0 },
  80     { 'w','i','n','s','o','c','k',0 },
  81     { 'w','n','a','s','p','i','3','2',0 },
  82     { 'w','o','w','3','2',0 },
  83     { 'w','s','2','_','3','2',0 },
  84     { 'w','s','o','c','k','3','2',0 },
  85     { 'x','1','1','d','r','v',0 }
  86 };
  87
  88 /* default if nothing else specified */
  89 static const enum loadorder_type default_loadorder[LOADORDER_NTYPES] =
  90 {
  91     LOADORDER_BI, LOADORDER_DLL, 0
  92 };
  93
  94 /* default for modules with an explicit path */
  95 static const enum loadorder_type default_path_loadorder[LOADORDER_NTYPES] =
  96 {
  97     LOADORDER_DLL, LOADORDER_BI, 0
  98 };
  99
 100 static const WCHAR separatorsW[] = {',',' ','\t',0};
 101
 102 static int init_done;
 103 static struct loadorder_list env_list;
 104
 105
 106 /***************************************************************************
 107  *      cmp_sort_func   (internal, static)
 108  *
 109  * Sorting and comparing function used in sort and search of loadorder
 110  * entries.
 111  */
 112 static int cmp_sort_func(const void *s1, const void *s2)
 113 {
 114     return strcmpiW(((module_loadorder_t *)s1)->modulename, ((module_loadorder_t *)s2)->modulename);
 115 }
 116
 117
 118 /***************************************************************************
 119  *      strcmp_func
 120  */
 121 static int strcmp_func(const void *s1, const void *s2)
 122 {
 123     return strcmpiW( (WCHAR *)s1, (WCHAR *)s2 );
 124 }
 125
 126
 127 /***************************************************************************
 128  *      get_basename
 129  *
 130  * Return the base name of a file name (i.e. remove the path components).
 131  */
 132 static const WCHAR *get_basename( const WCHAR *name )
 133 {
 134     const WCHAR *ptr;
 135
 136     if (name[0] && name[1] == ':') name += 2;  /* strip drive specification */
 137     if ((ptr = strrchrW( name, '\\' ))) name = ptr + 1;
 138     if ((ptr = strrchrW( name, '/' ))) name = ptr + 1;
 139     return name;
 140 }
 141
 142 /***************************************************************************
 143  *      remove_dll_ext
 144  *
 145  * Remove extension if it is ".dll".
 146  */
 147 static inline void remove_dll_ext( WCHAR *ext )
 148 {
 149     if (ext[0] == '.' &&
 150         toupperW(ext[1]) == 'D' &&
 151         toupperW(ext[2]) == 'L' &&
 152         toupperW(ext[3]) == 'L' &&
 153         !ext[4]) ext[0] = 0;
 154 }
 155
 156
 157 /***************************************************************************
 158  *      debugstr_loadorder
 159  *
 160  * Return a loadorder in printable form.
 161  */
 162 static const char *debugstr_loadorder( enum loadorder_type lo[] )
 163 {
 164     int i;
 165     char buffer[LOADORDER_NTYPES*3+1];
 166
 167     buffer[0] = 0;
 168     for(i = 0; i < LOADORDER_NTYPES; i++)
 169     {
 170         if (lo[i] == LOADORDER_INVALID) break;
 171         switch(lo[i])
 172         {
 173         case LOADORDER_DLL: strcat( buffer, "n," ); break;
 174         case LOADORDER_BI:  strcat( buffer, "b," ); break;
 175         default:            strcat( buffer, "?," ); break;
 176         }
 177     }
 178     if (buffer[0]) buffer[strlen(buffer)-1] = 0;
 179     return debugstr_a(buffer);
 180 }
 181
 182
 183 /***************************************************************************
 184  *      append_load_order
 185  *
 186  * Append a load order to the list if necessary.
 187  */
 188 static void append_load_order(enum loadorder_type lo[], enum loadorder_type append)
 189 {
 190     int i;
 191
 192     for (i = 0; i < LOADORDER_NTYPES; i++)
 193     {
 194         if (lo[i] == LOADORDER_INVALID)  /* append it here */
 195         {
 196             lo[i++] = append;
 197             lo[i] = LOADORDER_INVALID;
 198             return;
 199         }
 200         if (lo[i] == append) return;  /* already in the list */
 201     }
 202     assert(0);  /* cannot get here */
 203 }
 204
 205
 206 /***************************************************************************
 207  *      parse_load_order
 208  *
 209  * Parses the loadorder options from the configuration and puts it into
 210  * a structure.
 211  */
 212 static void parse_load_order( const WCHAR *order, enum loadorder_type lo[] )
 213 {
 214     lo[0] = LOADORDER_INVALID;
 215     while (*order)
 216     {
 217         order += strspnW( order, separatorsW );
 218         switch(*order)
 219         {
 220         case 'N':       /* Native */
 221         case 'n':
 222             append_load_order( lo, LOADORDER_DLL );
 223             break;
 224         case 'B':       /* Builtin */
 225         case 'b':
 226             append_load_order( lo, LOADORDER_BI );
 227             break;
 228         }
 229         order += strcspnW( order, separatorsW );
 230     }
 231 }
 232
 233
 234 /***************************************************************************
 235  *      add_load_order
 236  *
 237  * Adds an entry in the list of environment overrides.
 238  */
 239 static void add_load_order( const module_loadorder_t *plo )
 240 {
 241     int i;
 242
 243     for(i = 0; i < env_list.count; i++)
 244     {
 245         if(!cmp_sort_func(plo, &env_list.order[i] ))
 246         {
 247             /* replace existing option */
 248             memcpy( env_list.order[i].loadorder, plo->loadorder, sizeof(plo->loadorder));
 249             return;
 250         }
 251     }
 252
 253     if (i >= env_list.alloc)
 254     {
 255         /* No space in current array, make it larger */
 256         env_list.alloc += LOADORDER_ALLOC_CLUSTER;
 257         if (env_list.order)
 258             env_list.order = RtlReAllocateHeap(GetProcessHeap(), 0, env_list.order,
 259                                                env_list.alloc * sizeof(module_loadorder_t));
 260         else
 261             env_list.order = RtlAllocateHeap(GetProcessHeap(), 0,
 262                                              env_list.alloc * sizeof(module_loadorder_t));
 263         if(!env_list.order)
 264         {
 265             MESSAGE("Virtual memory exhausted\n");
 266             exit(1);
 267         }
 268     }
 269     memcpy(env_list.order[i].loadorder, plo->loadorder, sizeof(plo->loadorder));
 270     env_list.order[i].modulename = plo->modulename;
 271     env_list.count++;
 272 }
 273
 274
 275 /***************************************************************************
 276  *      add_load_order_set
 277  *
 278  * Adds a set of entries in the list of command-line overrides from the key parameter.
 279  */
 280 static void add_load_order_set( WCHAR *entry )
 281 {
 282     module_loadorder_t ldo;
 283     WCHAR *end = strchrW( entry, '=' );
 284
 285     if (!end) return;
 286     *end++ = 0;
 287     parse_load_order( end, ldo.loadorder );
 288
 289     while (*entry)
 290     {
 291         entry += strspnW( entry, separatorsW );
 292         end = entry + strcspnW( entry, separatorsW );
 293         if (*end) *end++ = 0;
 294         if (*entry)
 295         {
 296             WCHAR *ext = strrchrW(entry, '.');
 297             if (ext) remove_dll_ext( ext );
 298             ldo.modulename = entry;
 299             add_load_order( &ldo );
 300             entry = end;
 301         }
 302     }
 303 }
 304
 305
 306 /***************************************************************************
 307  *      init_load_order
 308  */
 309 static void init_load_order(void)
 310 {
 311     const char *order = getenv( "WINEDLLOVERRIDES" );
 312     UNICODE_STRING strW;
 313     WCHAR *entry, *next;
 314
 315     init_done = 1;
 316     if (!order) return;
 317
 318     if (!strcmp( order, "help" ))
 319     {
 320         MESSAGE( "Syntax:\n"
 321                  "  WINEDLLOVERRIDES=\"entry;entry;entry...\"\n"
 322                  "    where each entry is of the form:\n"
 323                  "        module[,module...]={native|builtin}[,{b|n}]\n"
 324                  "\n"
 325                  "    Only the first letter of the override (native or builtin)\n"
 326                  "    is significant.\n\n"
 327                  "Example:\n"
 328                  "  WINEDLLOVERRIDES=\"comdlg32,commdlg=n,b;shell,shell32=b\"\n" );
 329         exit(0);
 330     }
 331
 332     RtlCreateUnicodeStringFromAsciiz( &strW, order );
 333     entry = strW.Buffer;
 334     while (*entry)
 335     {
 336         while (*entry && *entry == ';') entry++;
 337         if (!*entry) break;
 338         next = strchrW( entry, ';' );
 339         if (next) *next++ = 0;
 340         else next = entry + strlenW(entry);
 341         add_load_order_set( entry );
 342         entry = next;
 343     }
 344
 345     /* sort the array for quick lookup */
 346     if (env_list.count)
 347         qsort(env_list.order, env_list.count, sizeof(env_list.order[0]), cmp_sort_func);
 348
 349     /* Note: we don't free the Unicode string because the
 350      * stored module names point inside it */
 351 }
 352
 353
 354 /***************************************************************************
 355  *      get_env_load_order
 356  *
 357  * Get the load order for a given module from the WINEDLLOVERRIDES environment variable.
 358  */
 359 static inline BOOL get_env_load_order( const WCHAR *module, enum loadorder_type lo[] )
 360 {
 361     module_loadorder_t tmp, *res = NULL;
 362
 363     tmp.modulename = module;
 364     /* some bsearch implementations (Solaris) are buggy when the number of items is 0 */
 365     if (env_list.count &&
 366         (res = bsearch(&tmp, env_list.order, env_list.count, sizeof(env_list.order[0]), cmp_sort_func)))
 367         memcpy( lo, res->loadorder, sizeof(res->loadorder) );
 368     return (res != NULL);
 369 }
 370
 371
 372 /***************************************************************************
 373  *      get_default_load_order
 374  *
 375  * Get the load order for a given module from the default list.
 376  */
 377 static inline BOOL get_default_load_order( const WCHAR *module, enum loadorder_type lo[] )
 378 {
 379     const int count = sizeof(default_builtins) / sizeof(default_builtins[0]);
 380     if (!bsearch( module, default_builtins, count, sizeof(default_builtins[0]), strcmp_func ))
 381         return FALSE;
 382     lo[0] = LOADORDER_BI;
 383     lo[1] = LOADORDER_INVALID;
 384     return TRUE;
 385 }
 386
 387
 388 /***************************************************************************
 389  *      open_app_key
 390  *
 391  * Open the registry key to the app-specific DllOverrides list.
 392  */
 393 static HKEY open_app_key( const WCHAR *app_name, const WCHAR *module )
 394 {
 395     OBJECT_ATTRIBUTES attr;
 396     UNICODE_STRING nameW;
 397     HKEY hkey;
 398     WCHAR *str;
 399     static const WCHAR AppDefaultsW[] = {'M','a','c','h','i','n','e','\\',
 400                                          'S','o','f','t','w','a','r','e','\\',
 401                                          'W','i','n','e','\\',
 402                                          'W','i','n','e','\\',
 403                                          'C','o','n','f','i','g','\\',
 404                                          'A','p','p','D','e','f','a','u','l','t','s','\\',0};
 405     static const WCHAR DllOverridesW[] = {'\\','D','l','l','O','v','e','r','r','i','d','e','s',0};
 406
 407     str = RtlAllocateHeap( GetProcessHeap(), 0,
 408                            sizeof(AppDefaultsW) + sizeof(DllOverridesW) +
 409                            strlenW(app_name) * sizeof(WCHAR) );
 410     if (!str) return 0;
 411     strcpyW( str, AppDefaultsW );
 412     strcatW( str, app_name );
 413     strcatW( str, DllOverridesW );
 414
 415     TRACE( "searching %s in %s\n", debugstr_w(module), debugstr_w(str) );
 416
 417     attr.Length = sizeof(attr);
 418     attr.RootDirectory = 0;
 419     attr.ObjectName = &nameW;
 420     attr.Attributes = 0;
 421     attr.SecurityDescriptor = NULL;
 422     attr.SecurityQualityOfService = NULL;
 423     RtlInitUnicodeString( &nameW, str );
 424
 425     if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) hkey = 0;
 426     RtlFreeHeap( GetProcessHeap(), 0, str );
 427     return hkey;
 428 }
 429
 430
 431 /***************************************************************************
 432  *      get_registry_value
 433  *
 434  * Load the registry loadorder value for a given module.
 435  */
 436 static BOOL get_registry_value( HKEY hkey, const WCHAR *module, enum loadorder_type lo[] )
 437 {
 438     UNICODE_STRING valueW;
 439     char buffer[80];
 440     DWORD count;
 441     BOOL ret;
 442
 443     RtlInitUnicodeString( &valueW, module );
 444
 445     if ((ret = !NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation,
 446                                  buffer, sizeof(buffer), &count )))
 447     {
 448         int i, n = 0;
 449         WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)buffer)->Data;
 450
 451         while (*str)
 452         {
 453             enum loadorder_type type = LOADORDER_INVALID;
 454
 455             while (*str == ',' || isspaceW(*str)) str++;
 456             if (!*str) break;
 457
 458             switch(tolowerW(*str))
 459             {
 460             case 'n': type = LOADORDER_DLL; break;
 461             case 'b': type = LOADORDER_BI; break;
 462             case 's': break;  /* no longer supported, ignore */
 463             case 0:   break;  /* end of string */
 464             default:
 465                 ERR("Invalid load order module-type %s, ignored\n", debugstr_w(str));
 466                 break;
 467             }
 468             if (type != LOADORDER_INVALID)
 469             {
 470                 for (i = 0; i < n; i++) if (lo[i] == type) break;  /* already specified */
 471                 if (i == n) lo[n++] = type;
 472             }
 473             while (*str && *str != ',' && !isspaceW(*str)) str++;
 474         }
 475         lo[n] = LOADORDER_INVALID;
 476     }
 477     return ret;
 478 }
 479
 480
 481 /***************************************************************************
 482  *      MODULE_GetBuiltinPath
 483  *
 484  * Get the path of a builtin module when the native file does not exist.
 485  */
 486 BOOL MODULE_GetBuiltinPath( const char *libname, const char *ext, char *filename, UINT size )
 487 {
 488     char *p;
 489     BOOL ret = FALSE;
 490     UINT len = GetSystemDirectoryA( filename, size );
 491
 492     if (FILE_contains_path( libname ))
 493     {
 494         char *tmp;
 495
 496         /* if the library name contains a path and can not be found,
 497          * return an error.
 498          * exception: if the path is the system directory, proceed,
 499          * so that modules which are not PE modules can be loaded.
 500          * If the library name does not contain a path and can not
 501          * be found, assume the system directory is meant */
 502
 503         if (strlen(libname) >= size) return FALSE;  /* too long */
 504         if (strchr( libname, '/' ))  /* need to convert slashes */
 505         {
 506             if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, strlen(libname)+1 ))) return FALSE;
 507             strcpy( tmp, libname );
 508             for (p = tmp; *p; p++) if (*p == '/') *p = '\\';
 509         }
 510         else tmp = (char *)libname;
 511
 512         if (!FILE_strncasecmp( filename, tmp, len ) && tmp[len] == '\\')
 513         {
 514             strcpy( filename, tmp );
 515             ret = TRUE;
 516         }
 517         if (tmp != libname) RtlFreeHeap( GetProcessHeap(), 0, tmp );
 518         if (!ret) return FALSE;
 519     }
 520     else
 521     {
 522         if (strlen(libname) >= size - len - 1) return FALSE;
 523         filename[len] = '\\';
 524         strcpy( filename+len+1, libname );
 525     }
 526
 527     /* if the filename doesn't have an extension, append the default */
 528     if (!(p = strrchr( filename, '.')) || strchr( p, '/' ) || strchr( p, '\\'))
 529     {
 530         if (strlen(filename) + strlen(ext) >= size) return FALSE;
 531         strcat( filename, ext );
 532     }
 533     return TRUE;
 534 }
 535
 536
 537 /***************************************************************************
 538  *      MODULE_GetLoadOrderW    (internal)
 539  *
 540  * Locate the loadorder of a module.
 541  * Any path is stripped from the path-argument and so are the extension
 542  * '.dll' and '.exe'. A lookup in the table can yield an override for
 543  * the specific dll. Otherwise the default load order is returned.
 544  */
 545 void MODULE_GetLoadOrderW( enum loadorder_type loadorder[], const WCHAR *app_name,
 546                           const WCHAR *path, BOOL win32 )
 547 {
 548     static const WCHAR DllOverridesW[] = {'M','a','c','h','i','n','e','\\',
 549                                           'S','o','f','t','w','a','r','e','\\',
 550                                           'W','i','n','e','\\',
 551                                           'W','i','n','e','\\',
 552                                           'C','o','n','f','i','g','\\',
 553                                           'D','l','l','O','v','e','r','r','i','d','e','s',0};
 554
 555     static HKEY std_key = (HKEY)-1;  /* key to standard section, cached */
 556     HKEY app_key = 0;
 557     WCHAR *module, *basename;
 558     int len;
 559
 560     if (!init_done) init_load_order();
 561
 562     TRACE("looking for %s\n", debugstr_w(path));
 563
 564     loadorder[0] = LOADORDER_INVALID;  /* in case something bad happens below */
 565
 566     /* Strip path information if the module resides in the system directory
 567      * (path is already stripped by caller for 16-bit modules)
 568      */
 569     if (win32)
 570     {
 571         WCHAR sysdir[MAX_PATH+1];
 572         UNICODE_STRING path_str, sysdir_str;
 573         if (!GetSystemDirectoryW( sysdir, MAX_PATH )) return;
 574
 575         RtlInitUnicodeString( &path_str, path );
 576         RtlInitUnicodeString( &sysdir_str, sysdir );
 577         if (RtlPrefixUnicodeString( &sysdir_str, &path_str, TRUE ))
 578         {
 579             path += sysdir_str.Length / sizeof(WCHAR);
 580             while (*path == '\\' || *path == '/') path++;
 581         }
 582     }
 583
 584     if (!(len = strlenW(path))) return;
 585     if (!(module = RtlAllocateHeap( GetProcessHeap(), 0, (len + 2) * sizeof(WCHAR) ))) return;
 586     strcpyW( module+1, path );  /* reserve module[0] for the wildcard char */
 587
 588     if (len >= 4) remove_dll_ext( module + 1 + len - 4 );
 589
 590     /* check environment variable first */
 591     if (get_env_load_order( module+1, loadorder ))
 592     {
 593         TRACE( "got environment %s for %s\n",
 594                debugstr_loadorder(loadorder), debugstr_w(path) );
 595         goto done;
 596     }
 597
 598     /* then explicit module name in AppDefaults */
 599     if (app_name)
 600     {
 601         app_key = open_app_key( app_name, module+1 );
 602         if (app_key && get_registry_value( app_key, module+1, loadorder ))
 603         {
 604             TRACE( "got app defaults %s for %s\n",
 605                    debugstr_loadorder(loadorder), debugstr_w(path) );
 606             goto done;
 607         }
 608     }
 609
 610     /* then explicit module name in standard section */
 611     if (std_key == (HKEY)-1)
 612     {
 613         OBJECT_ATTRIBUTES attr;
 614         UNICODE_STRING nameW;
 615
 616         attr.Length = sizeof(attr);
 617         attr.RootDirectory = 0;
 618         attr.ObjectName = &nameW;
 619         attr.Attributes = 0;
 620         attr.SecurityDescriptor = NULL;
 621         attr.SecurityQualityOfService = NULL;
 622         RtlInitUnicodeString( &nameW, DllOverridesW );
 623
 624         if (NtOpenKey( &std_key, KEY_ALL_ACCESS, &attr )) std_key = 0;
 625     }
 626
 627     if (std_key && get_registry_value( std_key, module+1, loadorder ))
 628     {
 629         TRACE( "got standard entry %s for %s\n",
 630                debugstr_loadorder(loadorder), debugstr_w(path) );
 631         goto done;
 632     }
 633
 634     /* then module basename preceded by '*' in AppDefaults */
 635     basename = (WCHAR *)get_basename( module+1 );
 636     basename[-1] = '*';
 637     if (app_key && get_registry_value( app_key, basename-1, loadorder ))
 638     {
 639         TRACE( "got app defaults basename %s for %s\n",
 640                debugstr_loadorder(loadorder), debugstr_w(path) );
 641         goto done;
 642     }
 643
 644     /* then module name preceded by '*' in standard section */
 645     if (std_key && get_registry_value( std_key, basename-1, loadorder ))
 646     {
 647         TRACE( "got standard base name %s for %s\n",
 648                debugstr_loadorder(loadorder), debugstr_w(path) );
 649         goto done;
 650     }
 651
 652     /* then base name matching compiled-in defaults */
 653     if (get_default_load_order( basename, loadorder ))
 654     {
 655         TRACE( "got compiled-in default %s for %s\n",
 656                debugstr_loadorder(loadorder), debugstr_w(path) );
 657         goto done;
 658     }
 659
 660     if (basename == module+1)
 661     {
 662         static const WCHAR wildcardW[] = {'*',0};
 663
 664         /* then wildcard entry in AppDefaults (only if no explicit path) */
 665         if (app_key && get_registry_value( app_key, wildcardW, loadorder ))
 666         {
 667             TRACE( "got app defaults wildcard %s for %s\n",
 668                    debugstr_loadorder(loadorder), debugstr_w(path) );
 669             goto done;
 670         }
 671
 672         /* then wildcard entry in standard section (only if no explicit path) */
 673         if (std_key && get_registry_value( std_key, wildcardW, loadorder ))
 674         {
 675             TRACE( "got standard wildcard %s for %s\n",
 676                    debugstr_loadorder(loadorder), debugstr_w(path) );
 677             goto done;
 678         }
 679
 680         /* and last the hard-coded default */
 681         memcpy( loadorder, default_loadorder, sizeof(default_loadorder) );
 682         TRACE( "got hardcoded default %s for %s\n",
 683                debugstr_loadorder(loadorder), debugstr_w(path) );
 684     }
 685     else  /* module contains an explicit path */
 686     {
 687         memcpy( loadorder, default_path_loadorder, sizeof(default_path_loadorder) );
 688         TRACE( "got hardcoded path default %s for %s\n",
 689                debugstr_loadorder(loadorder), debugstr_w(path) );
 690     }
 691
 692  done:
 693     if (app_key) NtClose( app_key );
 694     RtlFreeHeap( GetProcessHeap(), 0, module );
 695 }
 696
 697
 698 /***************************************************************************
 699  *      MODULE_GetLoadOrderA    (internal)
 700  *
 701  * Locate the loadorder of a module.
 702  * Any path is stripped from the path-argument and so are the extension
 703  * '.dll' and '.exe'. A lookup in the table can yield an override for
 704  * the specific dll. Otherwise the default load order is returned.
 705  *
 706  * FIXME: should be removed, everything should be Unicode.
 707  */
 708 void MODULE_GetLoadOrderA( enum loadorder_type loadorder[], const WCHAR *app_name,
 709                            const char *path, BOOL win32 )
 710 {
 711     UNICODE_STRING pathW;
 712
 713     RtlCreateUnicodeStringFromAsciiz( &pathW, path );
 714     MODULE_GetLoadOrderW( loadorder, app_name, pathW.Buffer, win32 );
 715     RtlFreeUnicodeString( &pathW );
 716 }