git.oblomov.eu Git - wine/blob - dlls/dbghelp/dbghelp.c

   1 /*
   2  * File dbghelp.c - generic routines (process) for dbghelp DLL
   3  *
   4  * Copyright (C) 2004, 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "dbghelp_private.h"
  24 #include "winerror.h"
  25 #include "psapi.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  29
  30 /* TODO
  31  *  - support for symbols' types is still partly missing
  32  *      + C++ support
  33  *      + funcargtype:s are (partly) wrong: they should be a specific struct (like
  34  *        typedef) pointing to the actual type (and not a direct access)
  35  *      + we should store the underlying type for an enum in the symt_enum struct
  36  *  - most options (dbghelp_options) are not used (loading lines, decoration,
  37  *    deferring reading of module symbols, public symbols...)
  38  *  - in symbol lookup by name, we don't use RE everywhere we should. Moreover, when
  39  *    we're supposed to use RE, it doesn't make use of our hash tables. Therefore,
  40  *    we could use hash if name isn't a RE, and fall back to a full search when we
  41  *    get a full RE
  42  *  - (un)decoration is not handled (should make winedump's code a (.a) library
  43  *    and link it to winedump, and potentially to msvcrt and dbghelp (check best
  44  *    way not to duplicate code in msvcrt & dbghelp)
  45  *  - msc:
  46  *      + we should add parameters' types to the function's signature
  47  *        while processing a function's parameters
  48  *      + get rid of MSC reading FIXME:s (lots of types are not defined)
  49  *      + support the PUBLICS_ONLY, NO_PUBLICS and AUTO_PUBLICS options
  50  *      + C++ management
  51  *  - stabs:
  52  *      + C++ management
  53  *  - implement the callback notification mechanism
  54  */
  55
  56 unsigned   dbghelp_options = SYMOPT_UNDNAME;
  57
  58 /***********************************************************************
  59  *           DllMain (DEBUGHLP.@)
  60  */
  61 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  62 {
  63     switch (fdwReason)
  64     {
  65     case DLL_PROCESS_ATTACH:    break;
  66     case DLL_PROCESS_DETACH:    break;
  67     case DLL_THREAD_ATTACH:     break;
  68     case DLL_THREAD_DETACH:     break;
  69     default:                    break;
  70     }
  71     return TRUE;
  72 }
  73
  74 static struct process* process_first /* = NULL */;
  75
  76 /******************************************************************
  77  *              process_find_by_handle
  78  *
  79  */
  80 struct process*    process_find_by_handle(HANDLE hProcess)
  81 {
  82     struct process* p;
  83
  84     for (p = process_first; p && p->handle != hProcess; p = p->next);
  85     if (!p) SetLastError(ERROR_INVALID_HANDLE);
  86     return p;
  87 }
  88
  89 /******************************************************************
  90  *              SymSetSearchPath (DBGHELP.@)
  91  *
  92  */
  93 BOOL WINAPI SymSetSearchPath(HANDLE hProcess, PSTR searchPath)
  94 {
  95     struct process* pcs = process_find_by_handle(hProcess);
  96
  97     if (!pcs) return FALSE;
  98     if (!searchPath) return FALSE;
  99
 100     HeapFree(GetProcessHeap(), 0, pcs->search_path);
 101     pcs->search_path = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(searchPath) + 1),
 102                               searchPath);
 103     return TRUE;
 104 }
 105
 106 /***********************************************************************
 107  *              SymGetSearchPath (DBGHELP.@)
 108  */
 109 BOOL WINAPI SymGetSearchPath(HANDLE hProcess, LPSTR szSearchPath,
 110                              DWORD SearchPathLength)
 111 {
 112     struct process* pcs = process_find_by_handle(hProcess);
 113     if (!pcs) return FALSE;
 114
 115     strncpy(szSearchPath, pcs->search_path, SearchPathLength);
 116     szSearchPath[SearchPathLength - 1] = '\0';
 117     return TRUE;
 118 }
 119
 120 /******************************************************************
 121  *              invade_process
 122  *
 123  * SymInitialize helper: loads in dbghelp all known (and loaded modules)
 124  * this assumes that hProcess is a handle on a valid process
 125  */
 126 static BOOL process_invade(HANDLE hProcess)
 127 {
 128     HMODULE     hMods[256];
 129     char        img[256];
 130     DWORD       i, sz;
 131     MODULEINFO  mi;
 132
 133     if (!EnumProcessModules(hProcess, hMods, sizeof(hMods), &sz))
 134         return FALSE; /* FIXME should grow hMods */
 135
 136     for (i = 0; i < sz / sizeof(HMODULE); i++)
 137     {
 138         if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) ||
 139             !GetModuleFileNameExA(hProcess, hMods[i], img, sizeof(img)) ||
 140             !SymLoadModule(hProcess, 0, img, NULL, (DWORD)mi.lpBaseOfDll, mi.SizeOfImage))
 141             return FALSE;
 142     }
 143
 144     return sz != 0;
 145 }
 146
 147 /******************************************************************
 148  *              SymInitialize (DBGHELP.@)
 149  *
 150  * The initialisation of a dbghelp's context.
 151  * Note that hProcess doesn't need to be a valid process handle (except
 152  * when fInvadeProcess is TRUE).
 153  * Since, we're also allow to load ELF (pure) libraries and Wine ELF libraries
 154  * containing PE (and NE) module(s), here's how we handle it:
 155  * - we load every module (ELF, NE, PE) passed in SymLoadModule
 156  * - in fInvadeProcess (in SymInitialize) is TRUE, we set up what is called ELF
 157  *   synchronization: hProcess should be a valid process handle, and we hook
 158  *   ourselves on hProcess's loaded ELF-modules, and keep this list in sync with
 159  *   our internal ELF modules representation (loading / unloading). This way,
 160  *   we'll pair every loaded builtin PE module with its ELF counterpart (and
 161  *   access its debug information).
 162  * - if fInvadeProcess (in SymInitialize) is FALSE, we won't be able to
 163  *   make the peering between a builtin PE module and its ELF counterpart, hence
 164  *   we won't be able to provide the requested debug information. We'll
 165  *   however be able to load native PE modules (and their debug information)
 166  *   without any trouble.
 167  * Note also that this scheme can be intertwined with the deferred loading
 168  * mechanism (ie only load the debug information when we actually need it).
 169  */
 170 BOOL WINAPI SymInitialize(HANDLE hProcess, PSTR UserSearchPath, BOOL fInvadeProcess)
 171 {
 172     struct process*     pcs;
 173
 174     TRACE("(%p %s %u)\n", hProcess, debugstr_a(UserSearchPath), fInvadeProcess);
 175
 176     if (process_find_by_handle(hProcess))
 177         FIXME("what to do ??\n");
 178
 179     pcs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pcs));
 180     if (!pcs) return FALSE;
 181
 182     pcs->handle = hProcess;
 183
 184     if (UserSearchPath)
 185     {
 186         pcs->search_path = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(UserSearchPath) + 1),
 187                                   UserSearchPath);
 188     }
 189     else
 190     {
 191         unsigned        size;
 192         unsigned        len;
 193
 194         pcs->search_path = HeapAlloc(GetProcessHeap(), 0, len = MAX_PATH);
 195         while ((size = GetCurrentDirectoryA(len, pcs->search_path)) >= len)
 196             pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, len *= 2);
 197         pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, size + 1);
 198
 199         len = GetEnvironmentVariableA("_NT_SYMBOL_PATH", NULL, 0);
 200         if (len)
 201         {
 202             pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, size + 1 + len + 1);
 203             pcs->search_path[size] = ';';
 204             GetEnvironmentVariableA("_NT_SYMBOL_PATH", pcs->search_path + size + 1, len);
 205             size += 1 + len;
 206         }
 207         len = GetEnvironmentVariableA("_NT_ALTERNATE_SYMBOL_PATH", NULL, 0);
 208         if (len)
 209         {
 210             pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, size + 1 + len + 1);
 211             pcs->search_path[size] = ';';
 212             GetEnvironmentVariableA("_NT_ALTERNATE_SYMBOL_PATH", pcs->search_path + size + 1, len);
 213             size += 1 + len;
 214         }
 215     }
 216
 217     pcs->lmodules = NULL;
 218     pcs->dbg_hdr_addr = 0;
 219     pcs->next = process_first;
 220     process_first = pcs;
 221
 222     if (fInvadeProcess)
 223     {
 224         if (!elf_read_wine_loader_dbg_info(pcs))
 225         {
 226             SymCleanup(hProcess);
 227             return FALSE;
 228         }
 229         process_invade(hProcess);
 230         elf_synchronize_module_list(pcs);
 231     }
 232     return TRUE;
 233 }
 234
 235 /******************************************************************
 236  *              SymCleanup (DBGHELP.@)
 237  *
 238  */
 239 BOOL WINAPI SymCleanup(HANDLE hProcess)
 240 {
 241     struct process**    ppcs;
 242     struct process*     next;
 243
 244     for (ppcs = &process_first; *ppcs; ppcs = &(*ppcs)->next)
 245     {
 246         if ((*ppcs)->handle == hProcess)
 247         {
 248             while ((*ppcs)->lmodules) module_remove(*ppcs, (*ppcs)->lmodules);
 249
 250             HeapFree(GetProcessHeap(), 0, (*ppcs)->search_path);
 251             next = (*ppcs)->next;
 252             HeapFree(GetProcessHeap(), 0, *ppcs);
 253             *ppcs = next;
 254             return TRUE;
 255         }
 256     }
 257     return FALSE;
 258 }
 259
 260 /******************************************************************
 261  *              SymSetOptions (DBGHELP.@)
 262  *
 263  */
 264 DWORD WINAPI SymSetOptions(DWORD opts)
 265 {
 266     return dbghelp_options = opts;
 267 }
 268
 269 /******************************************************************
 270  *              SymGetOptions (DBGHELP.@)
 271  *
 272  */
 273 DWORD WINAPI SymGetOptions(void)
 274 {
 275     return dbghelp_options;
 276 }
 277
 278 /******************************************************************
 279  *              SymSetContext (DBGHELP.@)
 280  *
 281  */
 282 BOOL WINAPI SymSetContext(HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame,
 283                           PIMAGEHLP_CONTEXT Context)
 284 {
 285     struct process* pcs = process_find_by_handle(hProcess);
 286     if (!pcs) return FALSE;
 287
 288     pcs->ctx_frame = *StackFrame;
 289     /* MSDN states that Context is not (no longer?) used */
 290     return TRUE;
 291 }
 292
 293 /***********************************************************************
 294  *              SymRegisterCallback (DBGHELP.@)
 295  */
 296 BOOL WINAPI SymRegisterCallback(HANDLE hProcess,
 297                                 PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
 298                                 PVOID UserContext)
 299 {
 300     FIXME("(%p, %p, %p): stub\n", hProcess, CallbackFunction, UserContext);
 301     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 302     return FALSE;
 303 }
 304
 305 /* This is imagehlp version not dbghelp !! */
 306 static API_VERSION api_version = { 4, 0, 2, 0 };
 307
 308 /***********************************************************************
 309  *           ImagehlpApiVersion (DBGHELP.@)
 310  */
 311 LPAPI_VERSION WINAPI ImagehlpApiVersion(VOID)
 312 {
 313     return &api_version;
 314 }
 315
 316 /***********************************************************************
 317  *           ImagehlpApiVersionEx (DBGHELP.@)
 318  */
 319 LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion)
 320 {
 321     if (!AppVersion) return NULL;
 322
 323     AppVersion->MajorVersion = api_version.MajorVersion;
 324     AppVersion->MinorVersion = api_version.MinorVersion;
 325     AppVersion->Revision = api_version.Revision;
 326     AppVersion->Reserved = api_version.Reserved;
 327
 328     return AppVersion;
 329 }