rsaenh: Store a key's value to the registry when a key is imported.
[wine] / 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_PDB:
526         {
527             struct pdb_lookup   pdb_lookup;
528             char                fn[MAX_PATH];
529
530             WideCharToMultiByte(CP_ACP, 0, buffer, -1, fn, MAX_PATH, NULL, NULL);
531             pdb_lookup.filename = fn;
532
533             if (!pdb_fetch_file_info(&pdb_lookup)) return FALSE;
534             matched++;
535             switch (pdb_lookup.kind)
536             {
537             case PDB_JG:
538                 if (mf->guid)
539                 {
540                     WARN("Found %s, but wrong PDB version\n", debugstr_w(buffer));
541                 }
542                 else if (pdb_lookup.u.jg.timestamp == mf->dw1)
543                     matched++;
544                 else
545                     WARN("Found %s, but wrong signature: %08x %08x\n",
546                          debugstr_w(buffer), pdb_lookup.u.jg.timestamp, mf->dw1);
547                 break;
548             case PDB_DS:
549                 if (!mf->guid)
550                 {
551                     WARN("Found %s, but wrong PDB version\n", debugstr_w(buffer));
552                 }
553                 else if (!memcmp(&pdb_lookup.u.ds.guid, mf->guid, sizeof(GUID)))
554                     matched++;
555                 else
556                     WARN("Found %s, but wrong GUID: %s %s\n",
557                          debugstr_w(buffer), debugstr_guid(&pdb_lookup.u.ds.guid),
558                          debugstr_guid(mf->guid));
559                 break;
560             }
561             if (pdb_lookup.age != mf->dw2)
562             {
563                 matched--;
564                 WARN("Found %s, but wrong age: %08x %08x\n",
565                      debugstr_w(buffer), pdb_lookup.age, mf->dw2);
566             }
567         }
568         break;
569     case DMT_DBG:
570         {
571             HANDLE  hFile, hMap;
572             void*   mapping;
573
574             timestamp = ~mf->dw1;
575             hFile = CreateFileW(buffer, GENERIC_READ, FILE_SHARE_READ, NULL,
576                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
577             if (hFile == INVALID_HANDLE_VALUE) return FALSE;
578             if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
579             {
580                 if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
581                 {
582                     const IMAGE_SEPARATE_DEBUG_HEADER*  hdr;
583                     hdr = mapping;
584
585                     if (hdr->Signature == IMAGE_SEPARATE_DEBUG_SIGNATURE)
586                     {
587                         matched++;
588                         timestamp = hdr->TimeDateStamp;
589                     }
590                     UnmapViewOfFile(mapping);
591                 }
592                 CloseHandle(hMap);
593             }
594             CloseHandle(hFile);
595             if (timestamp == mf->dw1) matched++;
596             else WARN("Found %s, but wrong timestamp\n", debugstr_w(buffer));
597         }
598         break;
599     default:
600         FIXME("What the heck??\n");
601         return FALSE;
602     }
603     if (matched > mf->matched)
604     {
605         strcpyW(mf->filename, buffer);
606         mf->matched = matched;
607     }
608     /* yes, EnumDirTree/do_search and SymFindFileInPath callbacks use the opposite
609      * convention to stop/continue enumeration. sigh.
610      */
611     return mf->matched == 2;
612 }
613
614 BOOL path_find_symbol_file(const struct process* pcs, PCSTR full_path,
615                            const GUID* guid, DWORD dw1, DWORD dw2, PSTR buffer,
616                            BOOL* is_unmatched)
617 {
618     struct module_find  mf;
619     WCHAR               full_pathW[MAX_PATH];
620     WCHAR               tmp[MAX_PATH];
621     WCHAR*              ptr;
622     const WCHAR*        filename;
623     WCHAR*              searchPath = pcs->search_path;
624
625     TRACE("(pcs = %p, full_path = %s, guid = %s, dw1 = 0x%08x, dw2 = 0x%08x, buffer = %p)\n",
626           pcs, debugstr_a(full_path), debugstr_guid(guid), dw1, dw2, buffer);
627
628     mf.guid = guid;
629     mf.dw1 = dw1;
630     mf.dw2 = dw2;
631     mf.matched = 0;
632
633     MultiByteToWideChar(CP_ACP, 0, full_path, -1, full_pathW, MAX_PATH);
634     filename = file_nameW(full_pathW);
635     mf.kind = module_get_type_by_name(filename);
636     *is_unmatched = FALSE;
637
638     /* first check full path to file */
639     if (module_find_cb(full_pathW, &mf))
640     {
641         WideCharToMultiByte(CP_ACP, 0, full_pathW, -1, buffer, MAX_PATH, NULL, NULL);
642         return TRUE;
643     }
644
645     while (searchPath)
646     {
647         ptr = strchrW(searchPath, ';');
648         if (ptr)
649         {
650             memcpy(tmp, searchPath, (ptr - searchPath) * sizeof(WCHAR));
651             tmp[ptr - searchPath] = '\0';
652             searchPath = ptr + 1;
653         }
654         else
655         {
656             strcpyW(tmp, searchPath);
657             searchPath = NULL;
658         }
659         if (do_searchW(filename, tmp, FALSE, module_find_cb, &mf))
660         {
661             /* return first fully matched file */
662             WideCharToMultiByte(CP_ACP, 0, tmp, -1, buffer, MAX_PATH, NULL, NULL);
663             return TRUE;
664         }
665     }
666     /* if no fully matching file is found, return the best matching file if any */
667     if ((dbghelp_options & SYMOPT_LOAD_ANYTHING) && mf.matched)
668     {
669         WideCharToMultiByte(CP_ACP, 0, mf.filename, -1, buffer, MAX_PATH, NULL, NULL);
670         *is_unmatched = TRUE;
671         return TRUE;
672     }
673     return FALSE;
674 }