ReactOS  0.4.14-dev-41-g31d7680
path.c
Go to the documentation of this file.
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 
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 static inline void file_pathW(const WCHAR* srcFileNameW,
53  WCHAR* dstFilePathW)
54 {
55  int len;
56 
57  for (len = strlenW(srcFileNameW) - 1; (len > 0) && (!is_sepW(srcFileNameW[len])); len--);
58 
59  strncpyW(dstFilePathW, srcFileNameW, len);
60  dstFilePathW[len] = L'\0';
61 }
62 
63 /******************************************************************
64  * FindDebugInfoFile (DBGHELP.@)
65  *
66  */
68 {
69  HANDLE h;
70 
73  if (h == INVALID_HANDLE_VALUE)
74  {
75  if (!SearchPathA(SymbolPath, file_name(FileName), NULL, MAX_PATH, DebugFilePath, NULL))
76  return NULL;
77  h = CreateFileA(DebugFilePath, GENERIC_READ, FILE_SHARE_READ, NULL,
79  }
80  return (h == INVALID_HANDLE_VALUE) ? NULL : h;
81 }
82 
83 /******************************************************************
84  * FindDebugInfoFileEx (DBGHELP.@)
85  *
86  */
88  PSTR DebugFilePath,
90  PVOID CallerData)
91 {
92  FIXME("(%s %s %s %p %p): stub\n", debugstr_a(FileName), debugstr_a(SymbolPath),
93  debugstr_a(DebugFilePath), Callback, CallerData);
94  return NULL;
95 }
96 
97 /******************************************************************
98  * FindExecutableImageExW (DBGHELP.@)
99  *
100  */
103 {
104  HANDLE h;
105 
106  if (Callback) FIXME("Unsupported callback yet\n");
107  if (!SearchPathW(SymbolPath, FileName, NULL, MAX_PATH, ImageFilePath, NULL))
108  return NULL;
109  h = CreateFileW(ImageFilePath, GENERIC_READ, FILE_SHARE_READ, NULL,
111  return (h == INVALID_HANDLE_VALUE) ? NULL : h;
112 }
113 
114 /******************************************************************
115  * FindExecutableImageEx (DBGHELP.@)
116  *
117  */
120 {
121  HANDLE h;
122 
123  if (Callback) FIXME("Unsupported callback yet\n");
124  if (!SearchPathA(SymbolPath, FileName, NULL, MAX_PATH, ImageFilePath, NULL))
125  return NULL;
126  h = CreateFileA(ImageFilePath, GENERIC_READ, FILE_SHARE_READ, NULL,
128  return (h == INVALID_HANDLE_VALUE) ? NULL : h;
129 }
130 
131 /******************************************************************
132  * FindExecutableImage (DBGHELP.@)
133  *
134  */
136 {
137  return FindExecutableImageEx(FileName, SymbolPath, ImageFilePath, NULL, NULL);
138 }
139 
140 /***********************************************************************
141  * MakeSureDirectoryPathExists (DBGHELP.@)
142  */
144 {
145  char path[MAX_PATH];
146  const char *p = DirPath;
147  int n;
148 
149  if (p[0] && p[1] == ':') p += 2;
150  while (*p == '\\') p++; /* skip drive root */
151  while ((p = strchr(p, '\\')) != NULL)
152  {
153  n = p - DirPath + 1;
154  memcpy(path, DirPath, n);
155  path[n] = '\0';
156  if( !CreateDirectoryA(path, NULL) &&
158  return FALSE;
159  p++;
160  }
163 
164  return TRUE;
165 }
166 
167 /******************************************************************
168  * SymMatchFileNameW (DBGHELP.@)
169  *
170  */
172  PWSTR* filestop, PWSTR* matchstop)
173 {
174  PCWSTR fptr;
175  PCWSTR mptr;
176 
177  TRACE("(%s %s %p %p)\n",
178  debugstr_w(file), debugstr_w(match), filestop, matchstop);
179 
180  fptr = file + strlenW(file) - 1;
181  mptr = match + strlenW(match) - 1;
182 
183  while (fptr >= file && mptr >= match)
184  {
185  if (toupperW(*fptr) != toupperW(*mptr) && !(is_sepW(*fptr) && is_sepW(*mptr)))
186  break;
187  fptr--; mptr--;
188  }
189  if (filestop) *filestop = (PWSTR)fptr;
190  if (matchstop) *matchstop = (PWSTR)mptr;
191 
192  return mptr == match - 1;
193 }
194 
195 /******************************************************************
196  * SymMatchFileName (DBGHELP.@)
197  *
198  */
200  PSTR* filestop, PSTR* matchstop)
201 {
202  PCSTR fptr;
203  PCSTR mptr;
204 
205  TRACE("(%s %s %p %p)\n", debugstr_a(file), debugstr_a(match), filestop, matchstop);
206 
207  fptr = file + strlen(file) - 1;
208  mptr = match + strlen(match) - 1;
209 
210  while (fptr >= file && mptr >= match)
211  {
212  if (toupper(*fptr) != toupper(*mptr) && !(is_sep(*fptr) && is_sep(*mptr)))
213  break;
214  fptr--; mptr--;
215  }
216  if (filestop) *filestop = (PSTR)fptr;
217  if (matchstop) *matchstop = (PSTR)mptr;
218 
219  return mptr == match - 1;
220 }
221 
224 {
225  HANDLE h;
227  unsigned pos;
228  BOOL found = FALSE;
229  static const WCHAR S_AllW[] = {'*','.','*','\0'};
230  static const WCHAR S_DotW[] = {'.','\0'};
231  static const WCHAR S_DotDotW[] = {'.','.','\0'};
232 
233  pos = strlenW(buffer);
234  if (buffer[pos - 1] != '\\') buffer[pos++] = '\\';
235  strcpyW(buffer + pos, S_AllW);
237  return FALSE;
238  /* doc doesn't specify how the tree is enumerated...
239  * doing a depth first based on, but may be wrong
240  */
241  do
242  {
243  if (!strcmpW(fd.cFileName, S_DotW) || !strcmpW(fd.cFileName, S_DotDotW)) continue;
244 
245  strcpyW(buffer + pos, fd.cFileName);
246  if (recurse && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
247  found = do_searchW(file, buffer, TRUE, cb, user);
248  else if (SymMatchFileNameW(buffer, file, NULL, NULL))
249  {
250  if (!cb || cb(buffer, user)) found = TRUE;
251  }
252  } while (!found && FindNextFileW(h, &fd));
253  if (!found) buffer[--pos] = '\0';
254  FindClose(h);
255 
256  return found;
257 }
258 
259 /***********************************************************************
260  * SearchTreeForFileW (DBGHELP.@)
261  */
263 {
264  TRACE("(%s, %s, %p)\n",
266  strcpyW(buffer, root);
267  return do_searchW(file, buffer, TRUE, NULL, NULL);
268 }
269 
270 /***********************************************************************
271  * SearchTreeForFile (DBGHELP.@)
272  */
274 {
277  WCHAR bufferW[MAX_PATH];
278  BOOL ret;
279 
282  ret = SearchTreeForFileW(rootW, fileW, bufferW);
283  if (ret)
284  WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
285  return ret;
286 }
287 
288 /******************************************************************
289  * EnumDirTreeW (DBGHELP.@)
290  *
291  *
292  */
295 {
296  TRACE("(%p %s %s %p %p %p)\n",
298 
299  strcpyW(buffer, root);
300  return do_searchW(file, buffer, TRUE, cb, user);
301 }
302 
303 /******************************************************************
304  * EnumDirTree (DBGHELP.@)
305  *
306  *
307  */
309 {
311  void* user;
312  char name[MAX_PATH];
313 };
314 
316 {
317  struct enum_dir_treeWA* edt = user;
318 
320  return edt->cb(edt->name, edt->user);
321 }
322 
325 {
328  WCHAR bufferW[MAX_PATH];
329  struct enum_dir_treeWA edt;
330  BOOL ret;
331 
332  edt.cb = cb;
333  edt.user = user;
336  if ((ret = EnumDirTreeW(hProcess, rootW, fileW, bufferW, enum_dir_treeWA, &edt)))
337  WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
338  return ret;
339 }
340 
341 struct sffip
342 {
344  void* user;
345 };
346 
347 /* checks that buffer (as found by matching the name) matches the info
348  * (information is based on file type)
349  * returns TRUE when file is found, FALSE to continue searching
350  * (NB this is the opposite convention of SymFindFileInPathProc)
351  */
353 {
354  struct sffip* s = user;
355 
356  if (!s->cb) return TRUE;
357  /* yes, EnumDirTree/do_search and SymFindFileInPath callbacks use the opposite
358  * convention to stop/continue enumeration. sigh.
359  */
360  return !(s->cb)(buffer, s->user);
361 }
362 
363 /******************************************************************
364  * SymFindFileInPathW (DBGHELP.@)
365  *
366  */
368  PVOID id, DWORD two, DWORD three, DWORD flags,
370  PVOID user)
371 {
372  struct sffip s;
373  struct process* pcs = process_find_by_handle(hProcess);
374  WCHAR tmp[MAX_PATH];
375  WCHAR* ptr;
376  const WCHAR* filename;
377 
378  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",
379  hProcess, debugstr_w(searchPath), debugstr_w(full_path),
380  id, two, three, flags, buffer, cb, user);
381 
382  if (!pcs) return FALSE;
383  if (!searchPath) searchPath = pcs->search_path;
384 
385  s.cb = cb;
386  s.user = user;
387 
388  filename = file_nameW(full_path);
389 
390  /* first check full path to file */
391  if (sffip_cb(full_path, &s))
392  {
393  strcpyW(buffer, full_path);
394  return TRUE;
395  }
396 
397  while (searchPath)
398  {
399  ptr = strchrW(searchPath, ';');
400  if (ptr)
401  {
402  memcpy(tmp, searchPath, (ptr - searchPath) * sizeof(WCHAR));
403  tmp[ptr - searchPath] = 0;
404  searchPath = ptr + 1;
405  }
406  else
407  {
408  strcpyW(tmp, searchPath);
409  searchPath = NULL;
410  }
411  if (do_searchW(filename, tmp, FALSE, sffip_cb, &s))
412  {
413  strcpyW(buffer, tmp);
414  return TRUE;
415  }
416  }
417  return FALSE;
418 }
419 
420 /******************************************************************
421  * SymFindFileInPath (DBGHELP.@)
422  *
423  */
425  PVOID id, DWORD two, DWORD three, DWORD flags,
427  PVOID user)
428 {
429  WCHAR searchPathW[MAX_PATH];
430  WCHAR full_pathW[MAX_PATH];
431  WCHAR bufferW[MAX_PATH];
432  struct enum_dir_treeWA edt;
433  BOOL ret;
434 
435  /* a PFINDFILEINPATHCALLBACK and a PENUMDIRTREE_CALLBACK have actually the
436  * same signature & semantics, hence we can reuse the EnumDirTree W->A
437  * conversion helper
438  */
439  edt.cb = cb;
440  edt.user = user;
441  if (searchPath)
442  MultiByteToWideChar(CP_ACP, 0, searchPath, -1, searchPathW, MAX_PATH);
443  MultiByteToWideChar(CP_ACP, 0, full_path, -1, full_pathW, MAX_PATH);
444  if ((ret = SymFindFileInPathW(hProcess, searchPath ? searchPathW : NULL, full_pathW,
445  id, two, three, flags,
446  bufferW, enum_dir_treeWA, &edt)))
447  WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
448  return ret;
449 }
450 
452 {
454  /* pe: dw1 DWORD:timestamp
455  * dw2 size of image (from PE header)
456  * pdb: guid PDB guid (if DS PDB file)
457  * or dw1 PDB timestamp (if JG PDB file)
458  * dw2 PDB age
459  * elf: dw1 DWORD:CRC 32 of ELF image (Wine only)
460  */
461  const GUID* guid;
465  unsigned matched;
466 };
467 
468 /* checks that buffer (as found by matching the name) matches the info
469  * (information is based on file type)
470  * returns TRUE when file is found, FALSE to continue searching
471  * (NB this is the opposite convention of SymFindFileInPathProc)
472  */
474 {
475  struct module_find* mf = user;
477  unsigned matched = 0;
478 
479  /* the matching weights:
480  * +1 if a file with same name is found and is a decent file of expected type
481  * +1 if first parameter and second parameter match
482  */
483 
484  /* FIXME: should check that id/two match the file pointed
485  * by buffer
486  */
487  switch (mf->kind)
488  {
489  case DMT_PE:
490  {
491  HANDLE hFile, hMap;
492  void* mapping;
493 
494  timestamp = ~mf->dw1;
495  size = ~mf->dw2;
498  if (hFile == INVALID_HANDLE_VALUE) return FALSE;
499  if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
500  {
501  if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
502  {
504  if (!nth)
505  {
507  CloseHandle(hMap);
509  return FALSE;
510  }
511  matched++;
515  }
516  CloseHandle(hMap);
517  }
519  if (timestamp != mf->dw1)
520  WARN("Found %s, but wrong timestamp\n", debugstr_w(buffer));
521  if (size != mf->dw2)
522  WARN("Found %s, but wrong size\n", debugstr_w(buffer));
523  if (timestamp == mf->dw1 && size == mf->dw2) matched++;
524  }
525  break;
526  case DMT_ELF:
528  {
529  matched++;
530  if (checksum == mf->dw1) matched++;
531  else
532  WARN("Found %s, but wrong checksums: %08x %08x\n",
533  debugstr_w(buffer), checksum, mf->dw1);
534  }
535  else
536  {
537  WARN("Couldn't read %s\n", debugstr_w(buffer));
538  return FALSE;
539  }
540  break;
541  case DMT_MACHO:
543  {
544  matched++;
545  if (checksum == mf->dw1) matched++;
546  else
547  WARN("Found %s, but wrong checksums: %08x %08x\n",
548  debugstr_w(buffer), checksum, mf->dw1);
549  }
550  else
551  {
552  WARN("Couldn't read %s\n", debugstr_w(buffer));
553  return FALSE;
554  }
555  break;
556  case DMT_PDB:
557  {
558  struct pdb_lookup pdb_lookup;
559  char fn[MAX_PATH];
560 
563 
564  if (mf->guid)
565  {
567  pdb_lookup.timestamp = 0;
568  pdb_lookup.guid = *mf->guid;
569  }
570  else
571  {
573  pdb_lookup.timestamp = mf->dw1;
574  /* pdb_loopkup.guid = */
575  }
576  pdb_lookup.age = mf->dw2;
577 
578  if (!pdb_fetch_file_info(&pdb_lookup, &matched)) return FALSE;
579  }
580  break;
581  case DMT_DBG:
582  {
583  HANDLE hFile, hMap;
584  void* mapping;
585 
586  timestamp = ~mf->dw1;
589  if (hFile == INVALID_HANDLE_VALUE) return FALSE;
590  if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
591  {
592  if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
593  {
595  hdr = mapping;
596 
597  if (hdr->Signature == IMAGE_SEPARATE_DEBUG_SIGNATURE)
598  {
599  matched++;
600  timestamp = hdr->TimeDateStamp;
601  }
603  }
604  CloseHandle(hMap);
605  }
607  if (timestamp == mf->dw1) matched++;
608  else WARN("Found %s, but wrong timestamp\n", debugstr_w(buffer));
609  }
610  break;
611  default:
612  FIXME("What the heck??\n");
613  return FALSE;
614  }
615  if (matched > mf->matched)
616  {
617  strcpyW(mf->filename, buffer);
618  mf->matched = matched;
619  }
620  /* yes, EnumDirTree/do_search and SymFindFileInPath callbacks use the opposite
621  * convention to stop/continue enumeration. sigh.
622  */
623  return mf->matched == 2;
624 }
625 
626 BOOL path_find_symbol_file(const struct process* pcs, const struct module* module,
627  PCSTR full_path, const GUID* guid, DWORD dw1, DWORD dw2,
628  PSTR buffer, BOOL* is_unmatched)
629 {
630  struct module_find mf;
631  WCHAR full_pathW[MAX_PATH];
632  WCHAR tmp[MAX_PATH];
633  WCHAR* ptr;
634  const WCHAR* filename;
635  WCHAR* searchPath = pcs->search_path;
636 
637  TRACE("(pcs = %p, full_path = %s, guid = %s, dw1 = 0x%08x, dw2 = 0x%08x, buffer = %p)\n",
638  pcs, debugstr_a(full_path), debugstr_guid(guid), dw1, dw2, buffer);
639 
640  mf.guid = guid;
641  mf.dw1 = dw1;
642  mf.dw2 = dw2;
643  mf.matched = 0;
644 
645  MultiByteToWideChar(CP_ACP, 0, full_path, -1, full_pathW, MAX_PATH);
646  filename = file_nameW(full_pathW);
648  *is_unmatched = FALSE;
649 
650  /* first check full path to file */
651  if (module_find_cb(full_pathW, &mf))
652  {
653  WideCharToMultiByte(CP_ACP, 0, full_pathW, -1, buffer, MAX_PATH, NULL, NULL);
654  return TRUE;
655  }
656 
657  /* FIXME: Use Environment-Variables (see MS docs)
658  _NT_SYMBOL_PATH and _NT_ALT_SYMBOL_PATH
659  FIXME: Implement "Standard Path Elements" (Path) ... (see MS docs)
660  do a search for (every?) path-element like this ...
661  <path>
662  <path>\dll
663  <path>\symbols\dll
664  (dll may be exe, or sys depending on the file extension) */
665 
666  /* 2. check module-path */
668  if (do_searchW(filename, tmp, FALSE, module_find_cb, &mf))
669  {
671  return TRUE;
672  }
673 
674  /* 3. check search-path */
675  while (searchPath)
676  {
677  ptr = strchrW(searchPath, ';');
678  if (ptr)
679  {
680  memcpy(tmp, searchPath, (ptr - searchPath) * sizeof(WCHAR));
681  tmp[ptr - searchPath] = '\0';
682  searchPath = ptr + 1;
683  }
684  else
685  {
686  strcpyW(tmp, searchPath);
687  searchPath = NULL;
688  }
689  if (do_searchW(filename, tmp, FALSE, module_find_cb, &mf))
690  {
691  /* return first fully matched file */
693  return TRUE;
694  }
695  }
696  /* if no fully matching file is found, return the best matching file if any */
698  {
700  *is_unmatched = TRUE;
701  return TRUE;
702  }
703  return FALSE;
704 }
char name[MAX_PATH]
Definition: path.c:312
BOOL WINAPI FindNextFileW(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:382
const uint16_t * PCWSTR
Definition: typedefs.h:55
WCHAR * search_path
#define TRUE
Definition: types.h:120
HANDLE WINAPI FindDebugInfoFileEx(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACK Callback, PVOID CallerData)
Definition: path.c:87
#define CloseHandle
Definition: compat.h:398
char hdr[14]
Definition: iptest.cpp:33
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:80
#define ERROR_SUCCESS
Definition: deptool.c:10
#define MapViewOfFile
Definition: compat.h:402
#define WideCharToMultiByte
Definition: compat.h:101
BOOL(CALLBACK * PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID)
Definition: compat.h:819
HANDLE WINAPI FindExecutableImage(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath)
Definition: path.c:135
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
Definition: match.c:28
uint16_t * PWSTR
Definition: typedefs.h:54
WINE_UNICODE_INLINE WCHAR * strchrW(const WCHAR *str, WCHAR ch)
Definition: unicode.h:248
BOOL WINAPI EnumDirTree(HANDLE hProcess, PCSTR root, PCSTR file, PSTR buffer, PENUMDIRTREE_CALLBACK cb, PVOID user)
Definition: path.c:323
static const WCHAR rootW[]
Definition: chain.c:69
#define CP_ACP
Definition: compat.h:99
#define WARN(fmt,...)
Definition: debug.h:111
BOOL(CALLBACK * PFINDFILEINPATHCALLBACKW)(_In_ PCWSTR, _In_ PVOID)
Definition: dbghelp.h:1891
void * user
Definition: path.c:311
static BOOL CALLBACK module_find_cb(PCWSTR buffer, PVOID user)
Definition: path.c:473
BOOL macho_fetch_file_info(HANDLE process, const WCHAR *name, unsigned long load_addr, DWORD_PTR *base, DWORD *size, DWORD *checksum) DECLSPEC_HIDDEN
#define CALLBACK
Definition: compat.h:27
enum module_type module_get_type_by_name(const WCHAR *name) DECLSPEC_HIDDEN
Definition: module.c:465
GLdouble n
Definition: glext.h:7729
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
HANDLE WINAPI FindExecutableImageEx(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath, PFIND_EXE_FILE_CALLBACK Callback, PVOID user)
Definition: path.c:118
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
GLuint buffer
Definition: glext.h:5915
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
enum module_type kind
Definition: path.c:453
static int fd
Definition: io.c:51
BOOL(CALLBACK * PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID)
Definition: compat.h:781
BOOL WINAPI SymMatchFileName(PCSTR file, PCSTR match, PSTR *filestop, PSTR *matchstop)
Definition: path.c:199
const char * filename
Definition: ioapi.h:135
static void file_pathW(const WCHAR *srcFileNameW, WCHAR *dstFilePathW)
Definition: path.c:52
#define IMAGE_SEPARATE_DEBUG_SIGNATURE
Definition: compat.h:143
DWORD ret
Definition: path.c:47
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
BOOL pdb_fetch_file_info(const struct pdb_lookup *pdb_lookup, unsigned *matched) DECLSPEC_HIDDEN
Definition: msc.c:2915
#define FILE_SHARE_READ
Definition: compat.h:125
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
#define strncpyW(d, s, n)
Definition: unicode.h:227
BOOL(CALLBACK * PFIND_EXE_FILE_CALLBACK)(_In_ HANDLE, _In_ PCSTR, _In_opt_ PVOID)
Definition: dbghelp.h:1934
enum pdb_kind kind
static const WCHAR * file_nameW(const WCHAR *str)
Definition: path.c:44
WCHAR LoadedImageName[256]
Definition: compat.h:727
static const char const char const char * SymbolPath
Definition: image.c:34
const GUID * guid
BOOL WINAPI SymFindFileInPath(HANDLE hProcess, PCSTR searchPath, PCSTR full_path, PVOID id, DWORD two, DWORD three, DWORD flags, PSTR buffer, PFINDFILEINPATHCALLBACK cb, PVOID user)
Definition: path.c:424
BOOL(CALLBACK * PENUMDIRTREE_CALLBACK)(_In_ PCSTR, _In_opt_ PVOID)
Definition: dbghelp.h:2049
BOOL WINAPI SymMatchFileNameW(PCWSTR file, PCWSTR match, PWSTR *filestop, PWSTR *matchstop)
Definition: path.c:171
DWORD WINAPI SearchPathA(IN LPCSTR lpPath OPTIONAL, IN LPCSTR lpFileName, IN LPCSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPSTR lpBuffer, OUT LPSTR *lpFilePart OPTIONAL)
Definition: path.c:1122
unsigned int BOOL
Definition: ntddk_ex.h:94
static double two
Definition: jn_yn.c:52
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
const WCHAR * str
BOOL WINAPI CreateDirectoryA(IN LPCSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:37
unsigned matched
Definition: path.c:465
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI EnumDirTreeW(HANDLE hProcess, PCWSTR root, PCWSTR file, PWSTR buffer, PENUMDIRTREE_CALLBACKW cb, PVOID user)
Definition: path.c:293
#define FILE_MAP_READ
Definition: compat.h:427
static BOOL CALLBACK sffip_cb(PCWSTR buffer, PVOID user)
Definition: path.c:352
#define debugstr_guid
Definition: kernel32.h:35
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
static const char * file_name(const char *str)
Definition: path.c:36
#define OPEN_EXISTING
Definition: compat.h:426
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
WINE_UNICODE_INLINE WCHAR toupperW(WCHAR ch)
Definition: unicode.h:141
BOOL WINAPI SymFindFileInPathW(HANDLE hProcess, PCWSTR searchPath, PCWSTR full_path, PVOID id, DWORD two, DWORD three, DWORD flags, PWSTR buffer, PFINDFILEINPATHCALLBACKW cb, PVOID user)
Definition: path.c:367
static BOOL is_sep(char ch)
Definition: path.c:33
int toupper(int c)
Definition: utclib.c:881
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
__wchar_t WCHAR
Definition: xmlstorage.h:180
static BOOL CALLBACK enum_dir_treeWA(PCWSTR name, PVOID user)
Definition: path.c:315
#define debugstr_a
Definition: kernel32.h:31
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:401
HANDLE WINAPI FindDebugInfoFile(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath)
Definition: path.c:67
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
unsigned dbghelp_options
Definition: dbghelp.c:72
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLenum GLenum GLenum mapping
Definition: glext.h:9031
WCHAR filename[MAX_PATH]
Definition: path.c:464
#define SetLastError(x)
Definition: compat.h:409
BOOL WINAPI MakeSureDirectoryPathExists(PCSTR DirPath)
Definition: path.c:143
static DWORD cb
Definition: integrity.c:41
GLbitfield flags
Definition: glext.h:7161
static BOOL do_searchW(PCWSTR file, PWSTR buffer, BOOL recurse, PENUMDIRTREE_CALLBACKW cb, PVOID user)
Definition: path.c:222
static BOOL is_sepW(WCHAR ch)
Definition: path.c:34
BOOL WINAPI SearchTreeForFile(PCSTR root, PCSTR file, PSTR buffer)
Definition: path.c:273
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126
static const WCHAR L[]
Definition: oid.c:1250
BOOL(CALLBACK * PFIND_DEBUG_FILE_CALLBACK)(_In_ HANDLE, _In_ PCSTR, _In_ PVOID)
Definition: dbghelp.h:1838
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
GLdouble s
Definition: gl.h:2039
#define GENERIC_READ
Definition: compat.h:124
module_type
static cab_ULONG checksum(const cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum)
Definition: fdi.c:353
_In_ HANDLE hFile
Definition: mswsock.h:90
WINE_DEFAULT_DEBUG_CHANNEL(dbghelp)
PFINDFILEINPATHCALLBACKW cb
Definition: path.c:343
#define SYMOPT_LOAD_ANYTHING
Definition: compat.h:640
const GUID * guid
Definition: path.c:461
DWORD WINAPI SearchPathW(IN LPCWSTR lpPath OPTIONAL, IN LPCWSTR lpFileName, IN LPCWSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart OPTIONAL)
Definition: path.c:1297
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:219
Definition: services.c:325
signed char * PSTR
Definition: retypes.h:7
HANDLE WINAPI FindExecutableImageExW(PCWSTR FileName, PCWSTR SymbolPath, PWSTR ImageFilePath, PFIND_EXE_FILE_CALLBACKW Callback, PVOID user)
Definition: path.c:101
Definition: path.c:341
#define PAGE_READONLY
Definition: compat.h:127
#define MultiByteToWideChar
Definition: compat.h:100
char * strchr(const char *String, int ch)
Definition: utclib.c:501
#define RtlImageNtHeader
Definition: compat.h:457
#define CreateFileW
Definition: compat.h:400
Definition: name.c:36
WINE_UNICODE_INLINE int strcmpW(const WCHAR *str1, const WCHAR *str2)
Definition: unicode.h:229
BOOL path_find_symbol_file(const struct process *pcs, const struct module *module, PCSTR full_path, const GUID *guid, DWORD dw1, DWORD dw2, PSTR buffer, BOOL *is_unmatched)
Definition: path.c:626
PENUMDIRTREE_CALLBACK cb
Definition: path.c:310
DWORD dw1
Definition: path.c:462
void * user
Definition: path.c:344
const char * PCSTR
Definition: typedefs.h:51
BOOL elf_fetch_file_info(const WCHAR *name, DWORD_PTR *base, DWORD *size, DWORD *checksum) DECLSPEC_HIDDEN
Definition: elf_module.c:1814
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:399
GLfloat GLfloat p
Definition: glext.h:8902
BOOL(CALLBACK * PFINDFILEINPATHCALLBACK)(_In_ PCSTR, _In_ PVOID)
Definition: dbghelp.h:1886
#define UnmapViewOfFile
Definition: compat.h:403
const char * filename
static const WCHAR fileW[]
Definition: url.c:111
LPFNPSPCALLBACK Callback
Definition: desk.c:111
IMAGEHLP_MODULEW64 module
void user(int argc, const char *argv[])
Definition: cmds.c:1350
DWORD dw2
Definition: path.c:463
BOOL WINAPI SearchTreeForFileW(PCWSTR root, PCWSTR file, PWSTR buffer)
Definition: path.c:262
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
Definition: fci.c:126
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502