| /* |
| * File source.c - source files management |
| * |
| * Copyright (C) 2004, Eric Pouech. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| * |
| */ |
| #include "config.h" |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <assert.h> |
| |
| #include "dbghelp_private.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); |
| |
| static struct module* rb_module; |
| struct source_rb |
| { |
| struct wine_rb_entry entry; |
| unsigned source; |
| }; |
| |
| int source_rb_compare(const void *key, const struct wine_rb_entry *entry) |
| { |
| const struct source_rb *t = WINE_RB_ENTRY_VALUE(entry, const struct source_rb, entry); |
| |
| return strcmp((const char*)key, rb_module->sources + t->source); |
| } |
| |
| /****************************************************************** |
| * source_find |
| * |
| * check whether a source file has already been stored |
| */ |
| static unsigned source_find(const char* name) |
| { |
| struct wine_rb_entry* e; |
| |
| e = wine_rb_get(&rb_module->sources_offsets_tree, name); |
| if (!e) return -1; |
| return WINE_RB_ENTRY_VALUE(e, struct source_rb, entry)->source; |
| } |
| |
| /****************************************************************** |
| * source_new |
| * |
| * checks if source exists. if not, add it |
| */ |
| unsigned source_new(struct module* module, const char* base, const char* name) |
| { |
| unsigned ret = -1; |
| const char* full; |
| char* tmp = NULL; |
| |
| if (!name) return ret; |
| if (!base || *name == '/') |
| full = name; |
| else |
| { |
| unsigned bsz = strlen(base); |
| |
| tmp = HeapAlloc(GetProcessHeap(), 0, bsz + 1 + strlen(name) + 1); |
| if (!tmp) return ret; |
| full = tmp; |
| strcpy(tmp, base); |
| if (tmp[bsz - 1] != '/') tmp[bsz++] = '/'; |
| strcpy(&tmp[bsz], name); |
| } |
| rb_module = module; |
| if (!module->sources || (ret = source_find(full)) == (unsigned)-1) |
| { |
| char* new; |
| int len = strlen(full) + 1; |
| struct source_rb* rb; |
| |
| if (module->sources_used + len + 1 > module->sources_alloc) |
| { |
| if (!module->sources) |
| { |
| module->sources_alloc = (module->sources_used + len + 1 + 255) & ~255; |
| new = HeapAlloc(GetProcessHeap(), 0, module->sources_alloc); |
| } |
| else |
| { |
| module->sources_alloc = max( module->sources_alloc * 2, |
| (module->sources_used + len + 1 + 255) & ~255 ); |
| new = HeapReAlloc(GetProcessHeap(), 0, module->sources, |
| module->sources_alloc); |
| } |
| if (!new) goto done; |
| module->sources = new; |
| } |
| ret = module->sources_used; |
| memcpy(module->sources + module->sources_used, full, len); |
| module->sources_used += len; |
| module->sources[module->sources_used] = '\0'; |
| if ((rb = pool_alloc(&module->pool, sizeof(*rb)))) |
| { |
| rb->source = ret; |
| wine_rb_put(&module->sources_offsets_tree, full, &rb->entry); |
| } |
| } |
| done: |
| HeapFree(GetProcessHeap(), 0, tmp); |
| return ret; |
| } |
| |
| /****************************************************************** |
| * source_get |
| * |
| * returns a stored source file name |
| */ |
| const char* source_get(const struct module* module, unsigned idx) |
| { |
| if (idx == -1) return ""; |
| assert(module->sources); |
| return module->sources + idx; |
| } |
| |
| /****************************************************************** |
| * SymEnumSourceFilesW (DBGHELP.@) |
| * |
| */ |
| BOOL WINAPI SymEnumSourceFilesW(HANDLE hProcess, ULONG64 ModBase, PCWSTR Mask, |
| PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles, |
| PVOID UserContext) |
| { |
| struct module_pair pair; |
| SOURCEFILEW sf; |
| char* ptr; |
| WCHAR* conversion_buffer = NULL; |
| DWORD conversion_buffer_len = 0; |
| |
| if (!cbSrcFiles) return FALSE; |
| pair.pcs = process_find_by_handle(hProcess); |
| if (!pair.pcs) return FALSE; |
| |
| if (ModBase) |
| { |
| pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN); |
| if (!module_get_debug(&pair)) return FALSE; |
| } |
| else |
| { |
| if (Mask[0] == '!') |
| { |
| pair.requested = module_find_by_nameW(pair.pcs, Mask + 1); |
| if (!module_get_debug(&pair)) return FALSE; |
| } |
| else |
| { |
| FIXME("Unsupported yet (should get info from current context)\n"); |
| return FALSE; |
| } |
| } |
| if (!pair.effective->sources) return FALSE; |
| for (ptr = pair.effective->sources; *ptr; ptr += strlen(ptr) + 1) |
| { |
| DWORD len = MultiByteToWideChar(CP_ACP, 0, ptr, -1, NULL, 0); |
| |
| if (len > conversion_buffer_len) |
| { |
| HeapFree(GetProcessHeap(), 0, conversion_buffer); |
| conversion_buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
| if (!conversion_buffer) return FALSE; |
| conversion_buffer_len = len; |
| } |
| |
| MultiByteToWideChar(CP_ACP, 0, ptr, -1, conversion_buffer, len); |
| |
| /* FIXME: not using Mask */ |
| sf.ModBase = ModBase; |
| sf.FileName = conversion_buffer; |
| if (!cbSrcFiles(&sf, UserContext)) break; |
| } |
| |
| HeapFree(GetProcessHeap(), 0, conversion_buffer); |
| return TRUE; |
| } |
| |
| struct enum_sources_files_context |
| { |
| PSYM_ENUMSOURCEFILES_CALLBACK callbackA; |
| PVOID caller_context; |
| char *conversion_buffer; |
| DWORD conversion_buffer_len; |
| DWORD callback_error; |
| }; |
| |
| static BOOL CALLBACK enum_source_files_W_to_A(PSOURCEFILEW source_file, PVOID context) |
| { |
| struct enum_sources_files_context *ctx = context; |
| SOURCEFILE source_fileA; |
| DWORD len; |
| |
| len = WideCharToMultiByte(CP_ACP, 0, source_file->FileName, -1, NULL, 0, NULL, NULL); |
| if (len > ctx->conversion_buffer_len) |
| { |
| char *ptr = ctx->conversion_buffer ? HeapReAlloc(GetProcessHeap(), 0, ctx->conversion_buffer, len) : |
| HeapAlloc(GetProcessHeap(), 0, len); |
| |
| if (!ptr) |
| { |
| ctx->callback_error = ERROR_OUTOFMEMORY; |
| return FALSE; |
| } |
| |
| ctx->conversion_buffer = ptr; |
| ctx->conversion_buffer_len = len; |
| } |
| |
| WideCharToMultiByte(CP_ACP, 0, source_file->FileName, -1, ctx->conversion_buffer, len, NULL, NULL); |
| |
| source_fileA.ModBase = source_file->ModBase; |
| source_fileA.FileName = ctx->conversion_buffer; |
| return ctx->callbackA(&source_fileA, ctx->caller_context); |
| } |
| |
| /****************************************************************** |
| * SymEnumSourceFiles (DBGHELP.@) |
| * |
| */ |
| BOOL WINAPI SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, PCSTR Mask, |
| PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles, |
| PVOID UserContext) |
| { |
| WCHAR *maskW = NULL; |
| PSYM_ENUMSOURCEFILES_CALLBACKW callbackW; |
| PVOID context; |
| struct enum_sources_files_context callback_context = {cbSrcFiles, UserContext}; |
| BOOL ret; |
| |
| if (Mask) |
| { |
| DWORD len = MultiByteToWideChar(CP_ACP, 0, Mask, -1, NULL, 0); |
| |
| maskW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
| if (!maskW) |
| { |
| SetLastError(ERROR_OUTOFMEMORY); |
| return FALSE; |
| } |
| |
| MultiByteToWideChar(CP_ACP, 0, Mask, -1, maskW, len); |
| } |
| |
| if (cbSrcFiles) |
| { |
| callbackW = enum_source_files_W_to_A; |
| context = &callback_context; |
| } |
| else |
| { |
| callbackW = NULL; |
| context = UserContext; |
| } |
| |
| ret = SymEnumSourceFilesW(hProcess, ModBase, maskW, callbackW, context); |
| |
| if (callback_context.callback_error) |
| { |
| SetLastError(callback_context.callback_error); |
| ret = FALSE; |
| } |
| |
| HeapFree(GetProcessHeap(), 0, callback_context.conversion_buffer); |
| HeapFree(GetProcessHeap(), 0, maskW); |
| |
| return ret; |
| } |
| |
| /****************************************************************** |
| * SymEnumSourceLines (DBGHELP.@) |
| * |
| */ |
| BOOL WINAPI SymEnumSourceLines(HANDLE hProcess, ULONG64 base, PCSTR obj, |
| PCSTR file, DWORD line, DWORD flags, |
| PSYM_ENUMLINES_CALLBACK EnumLinesCallback, |
| PVOID UserContext) |
| { |
| FIXME("%p %s %s %s %u %u %p %p: stub!\n", |
| hProcess, wine_dbgstr_longlong(base), debugstr_a(obj), debugstr_a(file), |
| line, flags, EnumLinesCallback, UserContext); |
| SetLastError(ERROR_NOT_SUPPORTED); |
| return FALSE; |
| } |
| |
| /****************************************************************** |
| * SymEnumSourceLinesW(DBGHELP.@) |
| * |
| */ |
| BOOL WINAPI SymEnumSourceLinesW(HANDLE hProcess, ULONG64 base, PCWSTR obj, |
| PCWSTR file, DWORD line, DWORD flags, |
| PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, |
| PVOID UserContext) |
| { |
| FIXME("%p %s %s %s %u %u %p %p: stub!\n", |
| hProcess, wine_dbgstr_longlong(base), debugstr_w(obj), debugstr_w(file), |
| line, flags, EnumLinesCallback, UserContext); |
| SetLastError(ERROR_NOT_SUPPORTED); |
| return FALSE; |
| } |
| |
| /****************************************************************** |
| * SymGetSourceFileToken (DBGHELP.@) |
| * |
| */ |
| BOOL WINAPI SymGetSourceFileToken(HANDLE hProcess, ULONG64 base, |
| PCSTR src, PVOID* token, DWORD* size) |
| { |
| FIXME("%p %s %s %p %p: stub!\n", |
| hProcess, wine_dbgstr_longlong(base), debugstr_a(src), token, size); |
| SetLastError(ERROR_NOT_SUPPORTED); |
| return FALSE; |
| } |
| |
| /****************************************************************** |
| * SymGetSourceFileTokenW (DBGHELP.@) |
| * |
| */ |
| BOOL WINAPI SymGetSourceFileTokenW(HANDLE hProcess, ULONG64 base, |
| PCWSTR src, PVOID* token, DWORD* size) |
| { |
| FIXME("%p %s %s %p %p: stub!\n", |
| hProcess, wine_dbgstr_longlong(base), debugstr_w(src), token, size); |
| SetLastError(ERROR_NOT_SUPPORTED); |
| return FALSE; |
| } |