| /* |
| * Copyright 1993 Robert J. Amstadt |
| * Copyright 1995 Alexandre Julliard |
| * |
| * 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 "wine/port.h" |
| |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wine/winbase16.h" |
| #include "winternl.h" |
| #include "kernel_private.h" |
| #include "kernel16_private.h" |
| #include "wine/unicode.h" |
| #include "wine/library.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(relay); |
| |
| #ifdef __i386__ |
| |
| static const WCHAR **debug_relay_excludelist; |
| static const WCHAR **debug_relay_includelist; |
| static const WCHAR **debug_snoop_excludelist; |
| static const WCHAR **debug_snoop_includelist; |
| |
| /* compare an ASCII and a Unicode string without depending on the current codepage */ |
| static inline int strcmpiAW( const char *strA, const WCHAR *strW ) |
| { |
| while (*strA && (toupperW((unsigned char)*strA) == toupperW(*strW))) { strA++; strW++; } |
| return toupperW((unsigned char)*strA) - toupperW(*strW); |
| } |
| |
| /* compare an ASCII and a Unicode string without depending on the current codepage */ |
| static inline int strncmpiAW( const char *strA, const WCHAR *strW, int n ) |
| { |
| int ret = 0; |
| for ( ; n > 0; n--, strA++, strW++) |
| if ((ret = toupperW((unsigned char)*strA) - toupperW(*strW)) || !*strA) break; |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * build_list |
| * |
| * Build a function list from a ';'-separated string. |
| */ |
| static const WCHAR **build_list( const WCHAR *buffer ) |
| { |
| int count = 1; |
| const WCHAR *p = buffer; |
| const WCHAR **ret; |
| |
| while ((p = strchrW( p, ';' ))) |
| { |
| count++; |
| p++; |
| } |
| /* allocate count+1 pointers, plus the space for a copy of the string */ |
| if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, |
| (count+1) * sizeof(WCHAR*) + (strlenW(buffer)+1) * sizeof(WCHAR) ))) |
| { |
| WCHAR *str = (WCHAR *)(ret + count + 1); |
| WCHAR *p = str; |
| |
| strcpyW( str, buffer ); |
| count = 0; |
| for (;;) |
| { |
| ret[count++] = p; |
| if (!(p = strchrW( p, ';' ))) break; |
| *p++ = 0; |
| } |
| ret[count++] = NULL; |
| } |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * RELAY16_InitDebugLists |
| * |
| * Build the relay include/exclude function lists. |
| */ |
| void RELAY16_InitDebugLists(void) |
| { |
| OBJECT_ATTRIBUTES attr; |
| UNICODE_STRING name; |
| char buffer[1024]; |
| HANDLE root, hkey; |
| DWORD count; |
| WCHAR *str; |
| static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\', |
| 'W','i','n','e','\\', |
| 'D','e','b','u','g',0}; |
| static const WCHAR RelayIncludeW[] = {'R','e','l','a','y','I','n','c','l','u','d','e',0}; |
| static const WCHAR RelayExcludeW[] = {'R','e','l','a','y','E','x','c','l','u','d','e',0}; |
| static const WCHAR SnoopIncludeW[] = {'S','n','o','o','p','I','n','c','l','u','d','e',0}; |
| static const WCHAR SnoopExcludeW[] = {'S','n','o','o','p','E','x','c','l','u','d','e',0}; |
| |
| RtlOpenCurrentUser( KEY_ALL_ACCESS, &root ); |
| attr.Length = sizeof(attr); |
| attr.RootDirectory = root; |
| attr.ObjectName = &name; |
| attr.Attributes = 0; |
| attr.SecurityDescriptor = NULL; |
| attr.SecurityQualityOfService = NULL; |
| RtlInitUnicodeString( &name, configW ); |
| |
| /* @@ Wine registry key: HKCU\Software\Wine\Debug */ |
| if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) hkey = 0; |
| NtClose( root ); |
| if (!hkey) return; |
| |
| str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)buffer)->Data; |
| RtlInitUnicodeString( &name, RelayIncludeW ); |
| if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count )) |
| { |
| debug_relay_includelist = build_list( str ); |
| } |
| |
| RtlInitUnicodeString( &name, RelayExcludeW ); |
| if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count )) |
| { |
| debug_relay_excludelist = build_list( str ); |
| } |
| |
| RtlInitUnicodeString( &name, SnoopIncludeW ); |
| if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count )) |
| { |
| debug_snoop_includelist = build_list( str ); |
| } |
| |
| RtlInitUnicodeString( &name, SnoopExcludeW ); |
| if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count )) |
| { |
| debug_snoop_excludelist = build_list( str ); |
| } |
| NtClose( hkey ); |
| } |
| |
| |
| /*********************************************************************** |
| * check_list |
| * |
| * Check if a given module and function is in the list. |
| */ |
| static BOOL check_list( const char *module, int ordinal, const char *func, const WCHAR **list ) |
| { |
| char ord_str[10]; |
| |
| sprintf( ord_str, "%d", ordinal ); |
| for(; *list; list++) |
| { |
| const WCHAR *p = strrchrW( *list, '.' ); |
| if (p && p > *list) /* check module and function */ |
| { |
| int len = p - *list; |
| if (strncmpiAW( module, *list, len-1 ) || module[len]) continue; |
| if (p[1] == '*' && !p[2]) return TRUE; |
| if (!strcmpiAW( ord_str, p + 1 )) return TRUE; |
| if (func && !strcmpiAW( func, p + 1 )) return TRUE; |
| } |
| else /* function only */ |
| { |
| if (func && !strcmpiAW( func, *list )) return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * RELAY_ShowDebugmsgRelay |
| * |
| * Simple function to decide if a particular debugging message is |
| * wanted. |
| */ |
| static BOOL RELAY_ShowDebugmsgRelay(const char *module, int ordinal, const char *func) |
| { |
| if (debug_relay_excludelist && check_list( module, ordinal, func, debug_relay_excludelist )) |
| return FALSE; |
| if (debug_relay_includelist && !check_list( module, ordinal, func, debug_relay_includelist )) |
| return FALSE; |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * SNOOP16_ShowDebugmsgSnoop |
| * |
| * Simple function to decide if a particular debugging message is |
| * wanted. |
| */ |
| int SNOOP16_ShowDebugmsgSnoop(const char *module, int ordinal, const char *func) |
| { |
| if (debug_snoop_excludelist && check_list( module, ordinal, func, debug_snoop_excludelist )) |
| return FALSE; |
| if (debug_snoop_includelist && !check_list( module, ordinal, func, debug_snoop_includelist )) |
| return FALSE; |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * get_entry_point |
| * |
| * Return the ordinal, name, and type info corresponding to a CS:IP address. |
| */ |
| static const CALLFROM16 *get_entry_point( STACK16FRAME *frame, LPSTR module, LPSTR func, WORD *pOrd ) |
| { |
| WORD i, max_offset; |
| register BYTE *p; |
| NE_MODULE *pModule; |
| ET_BUNDLE *bundle; |
| ET_ENTRY *entry; |
| |
| *pOrd = 0; |
| if (!(pModule = NE_GetPtr( FarGetOwner16( GlobalHandle16( frame->module_cs ) )))) |
| return NULL; |
| |
| max_offset = 0; |
| bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule->ne_enttab); |
| do |
| { |
| entry = (ET_ENTRY *)((BYTE *)bundle+6); |
| for (i = bundle->first + 1; i <= bundle->last; i++) |
| { |
| if ((entry->offs < frame->entry_ip) |
| && (entry->segnum == 1) /* code segment ? */ |
| && (entry->offs >= max_offset)) |
| { |
| max_offset = entry->offs; |
| *pOrd = i; |
| } |
| entry++; |
| } |
| } while ( (bundle->next) |
| && (bundle = (ET_BUNDLE *)((BYTE *)pModule+bundle->next))); |
| |
| /* Search for the name in the resident names table */ |
| /* (built-in modules have no non-resident table) */ |
| |
| p = (BYTE *)pModule + pModule->ne_restab; |
| memcpy( module, p + 1, *p ); |
| module[*p] = 0; |
| |
| while (*p) |
| { |
| p += *p + 1 + sizeof(WORD); |
| if (*(WORD *)(p + *p + 1) == *pOrd) break; |
| } |
| memcpy( func, p + 1, *p ); |
| func[*p] = 0; |
| |
| /* Retrieve entry point call structure */ |
| p = MapSL( MAKESEGPTR( frame->module_cs, frame->callfrom_ip ) ); |
| /* p now points to lret, get the start of CALLFROM16 structure */ |
| return (CALLFROM16 *)(p - (BYTE *)&((CALLFROM16 *)0)->ret); |
| } |
| |
| |
| extern int call_entry_point( void *func, int nb_args, const int *args ); |
| __ASM_GLOBAL_FUNC( call_entry_point, |
| "\tpushl %ebp\n" |
| "\tmovl %esp,%ebp\n" |
| "\tpushl %esi\n" |
| "\tpushl %edi\n" |
| "\tmovl 12(%ebp),%edx\n" |
| "\tshll $2,%edx\n" |
| "\tjz 1f\n" |
| "\tsubl %edx,%esp\n" |
| "\tandl $~15,%esp\n" |
| "\tmovl 12(%ebp),%ecx\n" |
| "\tmovl 16(%ebp),%esi\n" |
| "\tmovl %esp,%edi\n" |
| "\tcld\n" |
| "\trep; movsl\n" |
| "1:\tcall *8(%ebp)\n" |
| "\tleal -8(%ebp),%esp\n" |
| "\tpopl %edi\n" |
| "\tpopl %esi\n" |
| "\tpopl %ebp\n" |
| "\tret" ) |
| |
| |
| /*********************************************************************** |
| * relay_call_from_16_no_debug |
| * |
| * Same as relay_call_from_16 but doesn't print any debug information. |
| */ |
| static int relay_call_from_16_no_debug( void *entry_point, unsigned char *args16, CONTEXT86 *context, |
| const CALLFROM16 *call ) |
| { |
| unsigned int i, j, nb_args = 0; |
| int args32[20]; |
| |
| /* look for the ret instruction */ |
| for (j = 0; j < sizeof(call->ret)/sizeof(call->ret[0]); j++) |
| if (call->ret[j] == 0xca66 || call->ret[j] == 0xcb66) break; |
| |
| if (call->ret[j] == 0xcb66) /* cdecl */ |
| { |
| for (i = 0; i < 20; i++, nb_args++) |
| { |
| int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7; |
| |
| if (type == ARG_NONE) break; |
| switch(type) |
| { |
| case ARG_WORD: |
| args32[nb_args] = *(WORD *)args16; |
| args16 += sizeof(WORD); |
| break; |
| case ARG_SWORD: |
| args32[nb_args] = *(short *)args16; |
| args16 += sizeof(WORD); |
| break; |
| case ARG_LONG: |
| case ARG_SEGSTR: |
| args32[nb_args] = *(int *)args16; |
| args16 += sizeof(int); |
| break; |
| case ARG_PTR: |
| case ARG_STR: |
| args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 ); |
| args16 += sizeof(SEGPTR); |
| break; |
| case ARG_VARARG: |
| args32[nb_args] = (int)args16; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| else /* not cdecl */ |
| { |
| /* Start with the last arg */ |
| args16 += call->ret[j + 1]; |
| for (i = 0; i < 20; i++, nb_args++) |
| { |
| int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7; |
| |
| if (type == ARG_NONE) break; |
| switch(type) |
| { |
| case ARG_WORD: |
| args16 -= sizeof(WORD); |
| args32[nb_args] = *(WORD *)args16; |
| break; |
| case ARG_SWORD: |
| args16 -= sizeof(WORD); |
| args32[nb_args] = *(short *)args16; |
| break; |
| case ARG_LONG: |
| case ARG_SEGSTR: |
| args16 -= sizeof(int); |
| args32[nb_args] = *(int *)args16; |
| break; |
| case ARG_PTR: |
| case ARG_STR: |
| args16 -= sizeof(SEGPTR); |
| args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 ); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| if (!j) /* register function */ |
| args32[nb_args++] = (int)context; |
| |
| SYSLEVEL_CheckNotLevel( 2 ); |
| |
| return call_entry_point( entry_point, nb_args, args32 ); |
| } |
| |
| |
| /*********************************************************************** |
| * relay_call_from_16 |
| * |
| * Replacement for the 16-bit relay functions when relay debugging is on. |
| */ |
| int relay_call_from_16( void *entry_point, unsigned char *args16, CONTEXT86 *context ) |
| { |
| STACK16FRAME *frame; |
| WORD ordinal; |
| unsigned int i, j, nb_args = 0; |
| int ret_val, args32[20]; |
| char module[10], func[64]; |
| const CALLFROM16 *call; |
| |
| frame = CURRENT_STACK16; |
| call = get_entry_point( frame, module, func, &ordinal ); |
| if (!TRACE_ON(relay) || !RELAY_ShowDebugmsgRelay( module, ordinal, func )) |
| return relay_call_from_16_no_debug( entry_point, args16, context, call ); |
| |
| DPRINTF( "%04x:Call %s.%d: %s(",GetCurrentThreadId(), module, ordinal, func ); |
| |
| /* look for the ret instruction */ |
| for (j = 0; j < sizeof(call->ret)/sizeof(call->ret[0]); j++) |
| if (call->ret[j] == 0xca66 || call->ret[j] == 0xcb66) break; |
| |
| if (call->ret[j] == 0xcb66) /* cdecl */ |
| { |
| for (i = 0; i < 20; i++, nb_args++) |
| { |
| int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7; |
| |
| if (type == ARG_NONE) break; |
| if (i) DPRINTF( "," ); |
| switch(type) |
| { |
| case ARG_WORD: |
| DPRINTF( "%04x", *(WORD *)args16 ); |
| args32[nb_args] = *(WORD *)args16; |
| args16 += sizeof(WORD); |
| break; |
| case ARG_SWORD: |
| DPRINTF( "%04x", *(WORD *)args16 ); |
| args32[nb_args] = *(short *)args16; |
| args16 += sizeof(WORD); |
| break; |
| case ARG_LONG: |
| DPRINTF( "%08x", *(int *)args16 ); |
| args32[nb_args] = *(int *)args16; |
| args16 += sizeof(int); |
| break; |
| case ARG_PTR: |
| DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 ); |
| args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 ); |
| args16 += sizeof(SEGPTR); |
| break; |
| case ARG_STR: |
| DPRINTF( "%08x %s", *(int *)args16, |
| debugstr_a( MapSL(*(SEGPTR *)args16 ))); |
| args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 ); |
| args16 += sizeof(int); |
| break; |
| case ARG_SEGSTR: |
| DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16, |
| debugstr_a( MapSL(*(SEGPTR *)args16 )) ); |
| args32[nb_args] = *(SEGPTR *)args16; |
| args16 += sizeof(SEGPTR); |
| break; |
| case ARG_VARARG: |
| DPRINTF( "..." ); |
| args32[nb_args] = (int)args16; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| else /* not cdecl */ |
| { |
| /* Start with the last arg */ |
| args16 += call->ret[j + 1]; |
| for (i = 0; i < 20; i++, nb_args++) |
| { |
| int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7; |
| |
| if (type == ARG_NONE) break; |
| if (i) DPRINTF( "," ); |
| switch(type) |
| { |
| case ARG_WORD: |
| args16 -= sizeof(WORD); |
| args32[nb_args] = *(WORD *)args16; |
| DPRINTF( "%04x", *(WORD *)args16 ); |
| break; |
| case ARG_SWORD: |
| args16 -= sizeof(WORD); |
| args32[nb_args] = *(short *)args16; |
| DPRINTF( "%04x", *(WORD *)args16 ); |
| break; |
| case ARG_LONG: |
| args16 -= sizeof(int); |
| args32[nb_args] = *(int *)args16; |
| DPRINTF( "%08x", *(int *)args16 ); |
| break; |
| case ARG_PTR: |
| args16 -= sizeof(SEGPTR); |
| args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 ); |
| DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 ); |
| break; |
| case ARG_STR: |
| args16 -= sizeof(int); |
| args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 ); |
| DPRINTF( "%08x %s", *(int *)args16, |
| debugstr_a( MapSL(*(SEGPTR *)args16 ))); |
| break; |
| case ARG_SEGSTR: |
| args16 -= sizeof(SEGPTR); |
| args32[nb_args] = *(SEGPTR *)args16; |
| DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16, |
| debugstr_a( MapSL(*(SEGPTR *)args16 )) ); |
| break; |
| case ARG_VARARG: |
| DPRINTF( "..." ); |
| args32[nb_args] = (int)args16; |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| DPRINTF( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds ); |
| |
| if (!j) /* register function */ |
| { |
| args32[nb_args++] = (int)context; |
| DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08x\n", |
| (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx, |
| (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi, |
| (WORD)context->SegEs, context->EFlags ); |
| } |
| |
| SYSLEVEL_CheckNotLevel( 2 ); |
| |
| ret_val = call_entry_point( entry_point, nb_args, args32 ); |
| |
| SYSLEVEL_CheckNotLevel( 2 ); |
| |
| DPRINTF( "%04x:Ret %s.%d: %s() ",GetCurrentThreadId(), module, ordinal, func ); |
| if (!j) /* register function */ |
| { |
| DPRINTF("retval=none ret=%04x:%04x ds=%04x\n", |
| (WORD)context->SegCs, LOWORD(context->Eip), (WORD)context->SegDs); |
| DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08x\n", |
| (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx, |
| (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi, |
| (WORD)context->SegEs, context->EFlags ); |
| } |
| else |
| { |
| frame = CURRENT_STACK16; /* might have be changed by the entry point */ |
| if (j == 1) /* 16-bit return sequence */ |
| DPRINTF( "retval=%04x ret=%04x:%04x ds=%04x\n", |
| ret_val & 0xffff, frame->cs, frame->ip, frame->ds ); |
| else |
| DPRINTF( "retval=%08x ret=%04x:%04x ds=%04x\n", |
| ret_val, frame->cs, frame->ip, frame->ds ); |
| } |
| return ret_val; |
| } |
| |
| #else /* __i386__ */ |
| |
| /* |
| * Stubs for the CallTo16/CallFrom16 routines on non-Intel architectures |
| * (these will never be called but need to be present to satisfy the linker ...) |
| */ |
| |
| /*********************************************************************** |
| * __wine_call_from_16_regs (KERNEL32.@) |
| */ |
| void __wine_call_from_16_regs() |
| { |
| assert( FALSE ); |
| } |
| |
| DWORD WINAPI CALL32_CBClient( FARPROC proc, LPWORD args, DWORD *esi ) |
| { assert( FALSE ); } |
| |
| DWORD WINAPI CALL32_CBClientEx( FARPROC proc, LPWORD args, DWORD *esi, INT *nArgs ) |
| { assert( FALSE ); } |
| |
| #endif /* __i386__ */ |
