dlls/dbghelp/path.c

   1 /*
   2  * File path.c - managing path in debugging environments
   3  *
   4  * Copyright (C) 2004,2008, Eric Pouech
   5  *
   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.
  10  *
  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.
  15  *
  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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25
  26 #include "dbghelp_private.h"
  27 #include "winnls.h"
  28 #include "winternl.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  32
  33 static inline BOOL is_sep(char ch) {return ch == '/' || ch == '\\';}
  34 static inline BOOL is_sepW(WCHAR ch) {return ch == '/' || ch == '\\';}
  35
  36 static inline const char* file_name(const char* str)
  37 {
  38     const char*       p;
  39
  40     for (p = str + strlen(str) - 1; p >= str && !is_sep(*p); p--);
  41     return p + 1;
  42 }
  43
  44 static inline const WCHAR* file_nameW(const WCHAR* str)
  45 {
  46     const WCHAR*      p;
  47
  48     for (p = str + strlenW(str) - 1; p >= str && !is_sepW(*p); p--);
  49     return p + 1;
  50 }
  51
  52 /******************************************************************
  53  *              FindDebugInfoFile (DBGHELP.@)
  54  *
  55  */
  56 HANDLE WINAPI FindDebugInfoFile(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath)
  57 {
  58     HANDLE      h;
  59
  60     h = CreateFileA(FileName, GENERIC_READ, FILE_SHARE_READ, NULL,
  61                     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  62     if (h == INVALID_HANDLE_VALUE)
  63     {
  64         if (!SearchPathA(SymbolPath, file_name(FileName), NULL, MAX_PATH, DebugFilePath, NULL))
  65             return NULL;
  66         h = CreateFileA(DebugFilePath, GENERIC_READ, FILE_SHARE_READ, NULL,
  67                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  68     }
  69     return (h == INVALID_HANDLE_VALUE) ? NULL : h;
  70 }
  71
  72 /******************************************************************
  73  *              FindDebugInfoFileEx (DBGHELP.@)
  74  *
  75  */
  76 HANDLE WINAPI FindDebugInfoFileEx(PCSTR FileName, PCSTR SymbolPath,
  77                                   PSTR DebugFilePath,
  78                                   PFIND_DEBUG_FILE_CALLBACK Callback,
  79                                   PVOID CallerData)
  80 {
  81     FIXME("(%s %s %p %p %p): stub\n",
  82           debugstr_a(FileName), debugstr_a(SymbolPath), debugstr_a(DebugFilePath), Callback, CallerData);
  83     return NULL;
  84 }
  85
  86 /******************************************************************
  87  *              FindExecutableImageExW (DBGHELP.@)
  88  *
  89  */
  90 HANDLE WINAPI FindExecutableImageExW(PCWSTR FileName, PCWSTR SymbolPath, PWSTR ImageFilePath,
  91                                      PFIND_EXE_FILE_CALLBACKW Callback, PVOID user)
  92 {
  93     HANDLE h;
  94
  95     if (Callback) FIXME("Unsupported callback yet\n");
  96     if (!SearchPathW(SymbolPath, FileName, NULL, MAX_PATH, ImageFilePath, NULL))
  97         return NULL;
  98     h = CreateFileW(ImageFilePath, GENERIC_READ, FILE_SHARE_READ, NULL,
  99                     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 100     return (h == INVALID_HANDLE_VALUE) ? NULL : h;
 101 }
 102
 103 /******************************************************************
 104  *              FindExecutableImageEx (DBGHELP.@)
 105  *
 106  */
 107 HANDLE WINAPI FindExecutableImageEx(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath,
 108                                     PFIND_EXE_FILE_CALLBACK Callback, PVOID user)
 109 {
 110     HANDLE h;
 111
 112     if (Callback) FIXME("Unsupported callback yet\n");
 113     if (!SearchPathA(SymbolPath, FileName, NULL, MAX_PATH, ImageFilePath, NULL))
 114         return NULL;
 115     h = CreateFileA(ImageFilePath, GENERIC_READ, FILE_SHARE_READ, NULL,
 116                     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 117     return (h == INVALID_HANDLE_VALUE) ? NULL : h;
 118 }
 119
 120 /******************************************************************
 121  *              FindExecutableImage (DBGHELP.@)
 122  *
 123  */
 124 HANDLE WINAPI FindExecutableImage(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath)
 125 {
 126     return FindExecutableImageEx(FileName, SymbolPath, ImageFilePath, NULL, NULL);
 127 }
 128
 129 /***********************************************************************
 130  *           MakeSureDirectoryPathExists (DBGHELP.@)
 131  */
 132 BOOL WINAPI MakeSureDirectoryPathExists(PCSTR DirPath)
 133 {
 134     char path[MAX_PATH];
 135     const char *p = DirPath;
 136     int  n;
 137
 138     if (p[0] && p[1] == ':') p += 2;
 139     while (*p == '\\') p++; /* skip drive root */
 140     while ((p = strchr(p, '\\')) != NULL)
 141     {
 142        n = p - DirPath + 1;
 143        memcpy(path, DirPath, n);
 144        path[n] = '\0';
 145        if( !CreateDirectoryA(path, NULL)            &&
 146            (GetLastError() != ERROR_ALREADY_EXISTS))
 147            return FALSE;
 148        p++;
 149     }
 150     if (GetLastError() == ERROR_ALREADY_EXISTS)
 151        SetLastError(ERROR_SUCCESS);
 152
 153     return TRUE;
 154 }
 155
 156 /******************************************************************
 157  *              SymMatchFileNameW (DBGHELP.@)
 158  *
 159  */
 160 BOOL WINAPI SymMatchFileNameW(PCWSTR file, PCWSTR match,
 161                               PWSTR* filestop, PWSTR* matchstop)
 162 {
 163     PCWSTR fptr;
 164     PCWSTR mptr;
 165
 166     TRACE("(%s %s %p %p)\n",
 167           debugstr_w(file), debugstr_w(match), filestop, matchstop);
 168
 169     fptr = file + strlenW(file) - 1;
 170     mptr = match + strlenW(match) - 1;
 171
 172     while (fptr >= file && mptr >= match)
 173     {
 174         if (toupperW(*fptr) != toupperW(*mptr) && !(is_sepW(*fptr) && is_sepW(*mptr)))
 175             break;
 176         fptr--; mptr--;
 177     }
 178     if (filestop) *filestop = (PWSTR)fptr;
 179     if (matchstop) *matchstop = (PWSTR)mptr;
 180
 181     return mptr == match - 1;
 182 }
 183
 184 /******************************************************************
 185  *              SymMatchFileName (DBGHELP.@)
 186  *
 187  */
 188 BOOL WINAPI SymMatchFileName(PCSTR file, PCSTR match,
 189                              PSTR* filestop, PSTR* matchstop)
 190 {
 191     PCSTR fptr;
 192     PCSTR mptr;
 193
 194     TRACE("(%s %s %p %p)\n", debugstr_a(file), debugstr_a(match), filestop, matchstop);
 195
 196     fptr = file + strlen(file) - 1;
 197     mptr = match + strlen(match) - 1;
 198
 199     while (fptr >= file && mptr >= match)
 200     {
 201         if (toupper(*fptr) != toupper(*mptr) && !(is_sep(*fptr) && is_sep(*mptr)))
 202             break;
 203         fptr--; mptr--;
 204     }
 205     if (filestop) *filestop = (PSTR)fptr;
 206     if (matchstop) *matchstop = (PSTR)mptr;
 207
 208     return mptr == match - 1;
 209 }
 210
 211 static BOOL do_searchW(PCWSTR file, PWSTR buffer, BOOL recurse,
 212                        PENUMDIRTREE_CALLBACKW cb, PVOID user)
 213 {
 214     HANDLE              h;
 215     WIN32_FIND_DATAW    fd;
 216     unsigned            pos;
 217     BOOL                found = FALSE;
 218     static const WCHAR  S_AllW[] = {'*','.','*','\0'};
 219     static const WCHAR  S_DotW[] = {'.','\0'};
 220     static const WCHAR  S_DotDotW[] = {'.','.','\0'};
 221
 222     pos = strlenW(buffer);
 223     if (buffer[pos - 1] != '\\') buffer[pos++] = '\\';
 224     strcpyW(buffer + pos, S_AllW);
 225     if ((h = FindFirstFileW(buffer, &fd)) == INVALID_HANDLE_VALUE)
 226         return FALSE;
 227     /* doc doesn't specify how the tree is enumerated...
 228      * doing a depth first based on, but may be wrong
 229      */
 230     do
 231     {
 232         if (!strcmpW(fd.cFileName, S_DotW) || !strcmpW(fd.cFileName, S_DotDotW)) continue;
 233
 234         strcpyW(buffer + pos, fd.cFileName);
 235         if (recurse && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
 236             found = do_searchW(file, buffer, TRUE, cb, user);
 237         else if (SymMatchFileNameW(buffer, file, NULL, NULL))
 238         {
 239             if (!cb || cb(buffer, user)) found = TRUE;
 240         }
 241     } while (!found && FindNextFileW(h, &fd));
 242     if (!found) buffer[--pos] = '\0';
 243     FindClose(h);
 244
 245     return found;
 246 }
 247
 248 /***********************************************************************
 249  *           SearchTreeForFileW (DBGHELP.@)
 250  */
 251 BOOL WINAPI SearchTreeForFileW(PCWSTR root, PCWSTR file, PWSTR buffer)
 252 {
 253     TRACE("(%s, %s, %p)\n",
 254           debugstr_w(root), debugstr_w(file), buffer);
 255     strcpyW(buffer, root);
 256     return do_searchW(file, buffer, TRUE, NULL, NULL);
 257 }
 258
 259 /***********************************************************************
 260  *           SearchTreeForFile (DBGHELP.@)
 261  */
 262 BOOL WINAPI SearchTreeForFile(PCSTR root, PCSTR file, PSTR buffer)
 263 {
 264     WCHAR       rootW[MAX_PATH];
 265     WCHAR       fileW[MAX_PATH];
 266     WCHAR       bufferW[MAX_PATH];
 267     BOOL        ret;
 268
 269     MultiByteToWideChar(CP_ACP, 0, root, -1, rootW, MAX_PATH);
 270     MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, MAX_PATH);
 271     ret = SearchTreeForFileW(rootW, fileW, bufferW);
 272     if (ret)
 273         WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
 274     return ret;
 275 }
 276
 277 /******************************************************************
 278  *              EnumDirTreeW (DBGHELP.@)
 279  *
 280  *
 281  */
 282 BOOL WINAPI EnumDirTreeW(HANDLE hProcess, PCWSTR root, PCWSTR file,
 283                         PWSTR buffer, PENUMDIRTREE_CALLBACKW cb, PVOID user)
 284 {
 285     TRACE("(%p %s %s %p %p %p)\n",
 286           hProcess, debugstr_w(root), debugstr_w(file), buffer, cb, user);
 287
 288     strcpyW(buffer, root);
 289     return do_searchW(file, buffer, TRUE, cb, user);
 290 }
 291
 292 /******************************************************************
 293  *              EnumDirTree (DBGHELP.@)
 294  *
 295  *
 296  */
 297 struct enum_dir_treeWA
 298 {
 299     PENUMDIRTREE_CALLBACK       cb;
 300     void*                       user;
 301     char                        name[MAX_PATH];
 302 };
 303
 304 static BOOL CALLBACK enum_dir_treeWA(PCWSTR name, PVOID user)
 305 {
 306     struct enum_dir_treeWA*     edt = user;
 307
 308     WideCharToMultiByte(CP_ACP, 0, name, -1, edt->name, MAX_PATH, NULL, NULL);
 309     return edt->cb(edt->name, edt->user);
 310 }
 311
 312 BOOL WINAPI EnumDirTree(HANDLE hProcess, PCSTR root, PCSTR file,
 313                         PSTR buffer, PENUMDIRTREE_CALLBACK cb, PVOID user)
 314 {
 315     WCHAR                       rootW[MAX_PATH];
 316     WCHAR                       fileW[MAX_PATH];
 317     WCHAR                       bufferW[MAX_PATH];
 318     struct enum_dir_treeWA      edt;
 319     BOOL                        ret;
 320
 321     edt.cb = cb;
 322     edt.user = user;
 323     MultiByteToWideChar(CP_ACP, 0, root, -1, rootW, MAX_PATH);
 324     MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, MAX_PATH);
 325     if ((ret = EnumDirTreeW(hProcess, rootW, fileW, bufferW, enum_dir_treeWA, &edt)))
 326         WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
 327     return ret;
 328 }
 329
 330 struct sffip
 331 {
 332     PFINDFILEINPATHCALLBACKW    cb;
 333     void*                       user;
 334 };
 335
 336 /* checks that buffer (as found by matching the name) matches the info
 337  * (information is based on file type)
 338  * returns TRUE when file is found, FALSE to continue searching
 339  * (NB this is the opposite convention of SymFindFileInPathProc)
 340  */
 341 static BOOL CALLBACK sffip_cb(PCWSTR buffer, PVOID user)
 342 {
 343     struct sffip*       s = user;
 344
 345     if (!s->cb) return TRUE;
 346     /* yes, EnumDirTree/do_search and SymFindFileInPath callbacks use the opposite
 347      * convention to stop/continue enumeration. sigh.
 348      */
 349     return !(s->cb)(buffer, s->user);
 350 }
 351
 352 /******************************************************************
 353  *              SymFindFileInPathW (DBGHELP.@)
 354  *
 355  */
 356 BOOL WINAPI SymFindFileInPathW(HANDLE hProcess, PCWSTR searchPath, PCWSTR full_path,
 357                                PVOID id, DWORD two, DWORD three, DWORD flags,
 358                                PWSTR buffer, PFINDFILEINPATHCALLBACKW cb,
 359                                PVOID user)
 360 {
 361     struct sffip        s;
 362     struct process*     pcs = process_find_by_handle(hProcess);
 363     WCHAR               tmp[MAX_PATH];
 364     WCHAR*              ptr;
 365     const WCHAR*        filename;
 366
 367     TRACE("(hProcess = %p, searchPath = %s, full_path = %s, id = %p, two = 0x%08x, three = 0x%08x, flags = 0x%08x, buffer = %p, cb = %p, user = %p)\n",
 368           hProcess, debugstr_w(searchPath), debugstr_w(full_path),
 369           id, two, three, flags, buffer, cb, user);
 370
 371     if (!pcs) return FALSE;
 372     if (!searchPath) searchPath = pcs->search_path;
 373
 374     s.cb = cb;
 375     s.user = user;
 376
 377     filename = file_nameW(full_path);
 378
 379     /* first check full path to file */
 380     if (sffip_cb(full_path, &s))
 381     {
 382         strcpyW(buffer, full_path);
 383         return TRUE;
 384     }
 385
 386     while (searchPath)
 387     {
 388         ptr = strchrW(searchPath, ';');
 389         if (ptr)
 390         {
 391             memcpy(tmp, searchPath, (ptr - searchPath) * sizeof(WCHAR));
 392             tmp[ptr - searchPath] = 0;
 393             searchPath = ptr + 1;
 394         }
 395         else
 396         {
 397             strcpyW(tmp, searchPath);
 398             searchPath = NULL;
 399         }
 400         if (do_searchW(filename, tmp, FALSE, sffip_cb, &s))
 401         {
 402             strcpyW(buffer, tmp);
 403             return TRUE;
 404         }
 405     }
 406     return FALSE;
 407 }
 408
 409 /******************************************************************
 410  *              SymFindFileInPath (DBGHELP.@)
 411  *
 412  */
 413 BOOL WINAPI SymFindFileInPath(HANDLE hProcess, PCSTR searchPath, PCSTR full_path,
 414                               PVOID id, DWORD two, DWORD three, DWORD flags,
 415                               PSTR buffer, PFINDFILEINPATHCALLBACK cb,
 416                               PVOID user)
 417 {
 418     WCHAR                       searchPathW[MAX_PATH];
 419     WCHAR                       full_pathW[MAX_PATH];
 420     WCHAR                       bufferW[MAX_PATH];
 421     struct enum_dir_treeWA      edt;
 422     BOOL                        ret;
 423
 424     /* a PFINDFILEINPATHCALLBACK and a PENUMDIRTREE_CALLBACK have actually the
 425      * same signature & semantics, hence we can reuse the EnumDirTree W->A
 426      * conversion helper
 427      */
 428     edt.cb = cb;
 429     edt.user = user;
 430     if (searchPath)
 431         MultiByteToWideChar(CP_ACP, 0, searchPath, -1, searchPathW, MAX_PATH);
 432     MultiByteToWideChar(CP_ACP, 0, full_path, -1, full_pathW, MAX_PATH);
 433     if ((ret =  SymFindFileInPathW(hProcess, searchPath ? searchPathW : NULL, full_pathW,
 434                                    id, two, three, flags,
 435                                    bufferW, enum_dir_treeWA, &edt)))
 436         WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
 437     return ret;
 438 }
 439
 440 struct module_find
 441 {
 442     enum module_type            kind;
 443     /* pe:  dw1         DWORD:timestamp
 444      *      dw2         size of image (from PE header)
 445      * pdb: guid        PDB guid (if DS PDB file)
 446      *      or dw1      PDB timestamp (if JG PDB file)
 447      *      dw2         PDB age
 448      * elf: dw1         DWORD:CRC 32 of ELF image (Wine only)
 449      */
 450     const GUID*                 guid;
 451     DWORD                       dw1;
 452     DWORD                       dw2;
 453     WCHAR                       filename[MAX_PATH];
 454     unsigned                    matched;
 455 };
 456
 457 /* checks that buffer (as found by matching the name) matches the info
 458  * (information is based on file type)
 459  * returns TRUE when file is found, FALSE to continue searching
 460  * (NB this is the opposite convention of SymFindFileInPathProc)
 461  */
 462 static BOOL CALLBACK module_find_cb(PCWSTR buffer, PVOID user)
 463 {
 464     struct module_find* mf = user;
 465     DWORD               size, checksum, timestamp;
 466     unsigned            matched = 0;
 467
 468     /* the matching weights:
 469      * +1 if a file with same name is found and is a decent file of expected type
 470      * +1 if first parameter and second parameter match
 471      */
 472
 473     /* FIXME: should check that id/two match the file pointed
 474      * by buffer
 475      */
 476     switch (mf->kind)
 477     {
 478     case DMT_PE:
 479         {
 480             HANDLE  hFile, hMap;
 481             void*   mapping;
 482             DWORD   timestamp;
 483
 484             timestamp = ~mf->dw1;
 485             size = ~mf->dw2;
 486             hFile = CreateFileW(buffer, GENERIC_READ, FILE_SHARE_READ, NULL,
 487                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 488             if (hFile == INVALID_HANDLE_VALUE) return FALSE;
 489             if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
 490             {
 491                 if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
 492                 {
 493                     IMAGE_NT_HEADERS*   nth = RtlImageNtHeader(mapping);
 494
 495                     matched++;
 496                     timestamp = nth->FileHeader.TimeDateStamp;
 497                     size = nth->OptionalHeader.SizeOfImage;
 498                     UnmapViewOfFile(mapping);
 499                 }
 500                 CloseHandle(hMap);
 501             }
 502             CloseHandle(hFile);
 503             if (timestamp != mf->dw1)
 504                 WARN("Found %s, but wrong timestamp\n", debugstr_w(buffer));
 505             if (size != mf->dw2)
 506                 WARN("Found %s, but wrong size\n", debugstr_w(buffer));
 507             if (timestamp == mf->dw1 && size == mf->dw2) matched++;
 508         }
 509         break;
 510     case DMT_ELF:
 511         if (elf_fetch_file_info(buffer, 0, &size, &checksum))
 512         {
 513             matched++;
 514             if (checksum == mf->dw1) matched++;
 515             else
 516                 WARN("Found %s, but wrong checksums: %08x %08x\n",
 517                      debugstr_w(buffer), checksum, mf->dw1);
 518         }
 519         else
 520         {
 521             WARN("Couldn't read %s\n", debugstr_w(buffer));
 522             return FALSE;
 523         }
 524         break;
 525     case DMT_MACHO:
 526         if (macho_fetch_file_info(buffer, 0, &size, &checksum))
 527         {
 528             matched++;
 529             if (checksum == mf->dw1) matched++;
 530             else
 531                 WARN("Found %s, but wrong checksums: %08x %08x\n",
 532                      debugstr_w(buffer), checksum, mf->dw1);
 533         }
 534         else
 535         {
 536             WARN("Couldn't read %s\n", debugstr_w(buffer));
 537             return FALSE;
 538         }
 539         break;
 540     case DMT_PDB:
 541         {
 542             struct pdb_lookup   pdb_lookup;
 543             char                fn[MAX_PATH];
 544
 545             WideCharToMultiByte(CP_ACP, 0, buffer, -1, fn, MAX_PATH, NULL, NULL);
 546             pdb_lookup.filename = fn;
 547
 548             if (!pdb_fetch_file_info(&pdb_lookup)) return FALSE;
 549             matched++;
 550             switch (pdb_lookup.kind)
 551             {
 552             case PDB_JG:
 553                 if (mf->guid)
 554                 {
 555                     WARN("Found %s, but wrong PDB version\n", debugstr_w(buffer));
 556                 }
 557                 else if (pdb_lookup.u.jg.timestamp == mf->dw1)
 558                     matched++;
 559                 else
 560                     WARN("Found %s, but wrong signature: %08x %08x\n",
 561                          debugstr_w(buffer), pdb_lookup.u.jg.timestamp, mf->dw1);
 562                 break;
 563             case PDB_DS:
 564                 if (!mf->guid)
 565                 {
 566                     WARN("Found %s, but wrong PDB version\n", debugstr_w(buffer));
 567                 }
 568                 else if (!memcmp(&pdb_lookup.u.ds.guid, mf->guid, sizeof(GUID)))
 569                     matched++;
 570                 else
 571                     WARN("Found %s, but wrong GUID: %s %s\n",
 572                          debugstr_w(buffer), debugstr_guid(&pdb_lookup.u.ds.guid),
 573                          debugstr_guid(mf->guid));
 574                 break;
 575             }
 576             if (pdb_lookup.age != mf->dw2)
 577             {
 578                 matched--;
 579                 WARN("Found %s, but wrong age: %08x %08x\n",
 580                      debugstr_w(buffer), pdb_lookup.age, mf->dw2);
 581             }
 582         }
 583         break;
 584     case DMT_DBG:
 585         {
 586             HANDLE  hFile, hMap;
 587             void*   mapping;
 588
 589             timestamp = ~mf->dw1;
 590             hFile = CreateFileW(buffer, GENERIC_READ, FILE_SHARE_READ, NULL,
 591                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 592             if (hFile == INVALID_HANDLE_VALUE) return FALSE;
 593             if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
 594             {
 595                 if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
 596                 {
 597                     const IMAGE_SEPARATE_DEBUG_HEADER*  hdr;
 598                     hdr = mapping;
 599
 600                     if (hdr->Signature == IMAGE_SEPARATE_DEBUG_SIGNATURE)
 601                     {
 602                         matched++;
 603                         timestamp = hdr->TimeDateStamp;
 604                     }
 605                     UnmapViewOfFile(mapping);
 606                 }
 607                 CloseHandle(hMap);
 608             }
 609             CloseHandle(hFile);
 610             if (timestamp == mf->dw1) matched++;
 611             else WARN("Found %s, but wrong timestamp\n", debugstr_w(buffer));
 612         }
 613         break;
 614     default:
 615         FIXME("What the heck??\n");
 616         return FALSE;
 617     }
 618     if (matched > mf->matched)
 619     {
 620         strcpyW(mf->filename, buffer);
 621         mf->matched = matched;
 622     }
 623     /* yes, EnumDirTree/do_search and SymFindFileInPath callbacks use the opposite
 624      * convention to stop/continue enumeration. sigh.
 625      */
 626     return mf->matched == 2;
 627 }
 628
 629 BOOL path_find_symbol_file(const struct process* pcs, PCSTR full_path,
 630                            const GUID* guid, DWORD dw1, DWORD dw2, PSTR buffer,
 631                            BOOL* is_unmatched)
 632 {
 633     struct module_find  mf;
 634     WCHAR               full_pathW[MAX_PATH];
 635     WCHAR               tmp[MAX_PATH];
 636     WCHAR*              ptr;
 637     const WCHAR*        filename;
 638     WCHAR*              searchPath = pcs->search_path;
 639
 640     TRACE("(pcs = %p, full_path = %s, guid = %s, dw1 = 0x%08x, dw2 = 0x%08x, buffer = %p)\n",
 641           pcs, debugstr_a(full_path), debugstr_guid(guid), dw1, dw2, buffer);
 642
 643     mf.guid = guid;
 644     mf.dw1 = dw1;
 645     mf.dw2 = dw2;
 646     mf.matched = 0;
 647
 648     MultiByteToWideChar(CP_ACP, 0, full_path, -1, full_pathW, MAX_PATH);
 649     filename = file_nameW(full_pathW);
 650     mf.kind = module_get_type_by_name(filename);
 651     *is_unmatched = FALSE;
 652
 653     /* first check full path to file */
 654     if (module_find_cb(full_pathW, &mf))
 655     {
 656         WideCharToMultiByte(CP_ACP, 0, full_pathW, -1, buffer, MAX_PATH, NULL, NULL);
 657         return TRUE;
 658     }
 659
 660     while (searchPath)
 661     {
 662         ptr = strchrW(searchPath, ';');
 663         if (ptr)
 664         {
 665             memcpy(tmp, searchPath, (ptr - searchPath) * sizeof(WCHAR));
 666             tmp[ptr - searchPath] = '\0';
 667             searchPath = ptr + 1;
 668         }
 669         else
 670         {
 671             strcpyW(tmp, searchPath);
 672             searchPath = NULL;
 673         }
 674         if (do_searchW(filename, tmp, FALSE, module_find_cb, &mf))
 675         {
 676             /* return first fully matched file */
 677             WideCharToMultiByte(CP_ACP, 0, tmp, -1, buffer, MAX_PATH, NULL, NULL);
 678             return TRUE;
 679         }
 680     }
 681     /* if no fully matching file is found, return the best matching file if any */
 682     if ((dbghelp_options & SYMOPT_LOAD_ANYTHING) && mf.matched)
 683     {
 684         WideCharToMultiByte(CP_ACP, 0, mf.filename, -1, buffer, MAX_PATH, NULL, NULL);
 685         *is_unmatched = TRUE;
 686         return TRUE;
 687     }
 688     return FALSE;
 689 }