2 * Copyright 1993 Robert J. Amstadt
3 * Copyright 1995 Alexandre Julliard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "wine/port.h"
31 #include "wine/winbase16.h"
32 #include "kernel_private.h"
33 #include "kernel16_private.h"
34 #include "wine/unicode.h"
35 #include "wine/library.h"
36 #include "wine/debug.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(relay);
42 static const WCHAR **debug_relay_excludelist;
43 static const WCHAR **debug_relay_includelist;
44 static const WCHAR **debug_snoop_excludelist;
45 static const WCHAR **debug_snoop_includelist;
47 /* compare an ASCII and a Unicode string without depending on the current codepage */
48 inline static int strcmpiAW( const char *strA, const WCHAR *strW )
50 while (*strA && (toupperW((unsigned char)*strA) == toupperW(*strW))) { strA++; strW++; }
51 return toupperW((unsigned char)*strA) - toupperW(*strW);
54 /* compare an ASCII and a Unicode string without depending on the current codepage */
55 inline static int strncmpiAW( const char *strA, const WCHAR *strW, int n )
58 for ( ; n > 0; n--, strA++, strW++)
59 if ((ret = toupperW((unsigned char)*strA) - toupperW(*strW)) || !*strA) break;
63 /***********************************************************************
66 * Build a function list from a ';'-separated string.
68 static const WCHAR **build_list( const WCHAR *buffer )
71 const WCHAR *p = buffer;
74 while ((p = strchrW( p, ';' )))
79 /* allocate count+1 pointers, plus the space for a copy of the string */
80 if ((ret = RtlAllocateHeap( GetProcessHeap(), 0,
81 (count+1) * sizeof(WCHAR*) + (strlenW(buffer)+1) * sizeof(WCHAR) )))
83 WCHAR *str = (WCHAR *)(ret + count + 1);
86 strcpyW( str, buffer );
91 if (!(p = strchrW( p, ';' ))) break;
100 /***********************************************************************
101 * RELAY16_InitDebugLists
103 * Build the relay include/exclude function lists.
105 void RELAY16_InitDebugLists(void)
107 OBJECT_ATTRIBUTES attr;
113 static const WCHAR configW[] = {'M','a','c','h','i','n','e','\\',
114 'S','o','f','t','w','a','r','e','\\',
115 'W','i','n','e','\\',
116 'W','i','n','e','\\',
117 'C','o','n','f','i','g','\\',
118 'D','e','b','u','g',0};
119 static const WCHAR RelayIncludeW[] = {'R','e','l','a','y','I','n','c','l','u','d','e',0};
120 static const WCHAR RelayExcludeW[] = {'R','e','l','a','y','E','x','c','l','u','d','e',0};
121 static const WCHAR SnoopIncludeW[] = {'S','n','o','o','p','I','n','c','l','u','d','e',0};
122 static const WCHAR SnoopExcludeW[] = {'S','n','o','o','p','E','x','c','l','u','d','e',0};
124 attr.Length = sizeof(attr);
125 attr.RootDirectory = 0;
126 attr.ObjectName = &name;
128 attr.SecurityDescriptor = NULL;
129 attr.SecurityQualityOfService = NULL;
130 RtlInitUnicodeString( &name, configW );
132 if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return;
134 str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)buffer)->Data;
135 RtlInitUnicodeString( &name, RelayIncludeW );
136 if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
138 debug_relay_includelist = build_list( str );
141 RtlInitUnicodeString( &name, RelayExcludeW );
142 if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
144 debug_relay_excludelist = build_list( str );
147 RtlInitUnicodeString( &name, SnoopIncludeW );
148 if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
150 debug_snoop_includelist = build_list( str );
153 RtlInitUnicodeString( &name, SnoopExcludeW );
154 if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
156 debug_snoop_excludelist = build_list( str );
162 /***********************************************************************
165 * Check if a given module and function is in the list.
167 static BOOL check_list( const char *module, int ordinal, const char *func, const WCHAR **list )
171 sprintf( ord_str, "%d", ordinal );
174 const WCHAR *p = strrchrW( *list, '.' );
175 if (p && p > *list) /* check module and function */
178 if (strncmpiAW( module, *list, len-1 ) || module[len]) continue;
179 if (p[1] == '*' && !p[2]) return TRUE;
180 if (!strcmpiAW( ord_str, p + 1 )) return TRUE;
181 if (func && !strcmpiAW( func, p + 1 )) return TRUE;
183 else /* function only */
185 if (func && !strcmpiAW( func, *list )) return TRUE;
192 /***********************************************************************
193 * RELAY_ShowDebugmsgRelay
195 * Simple function to decide if a particular debugging message is
198 static BOOL RELAY_ShowDebugmsgRelay(const char *module, int ordinal, const char *func)
200 if (debug_relay_excludelist && check_list( module, ordinal, func, debug_relay_excludelist ))
202 if (debug_relay_includelist && !check_list( module, ordinal, func, debug_relay_includelist ))
208 /***********************************************************************
209 * SNOOP16_ShowDebugmsgSnoop
211 * Simple function to decide if a particular debugging message is
214 int SNOOP16_ShowDebugmsgSnoop(const char *module, int ordinal, const char *func)
216 if (debug_snoop_excludelist && check_list( module, ordinal, func, debug_snoop_excludelist ))
218 if (debug_snoop_includelist && !check_list( module, ordinal, func, debug_snoop_includelist ))
224 /***********************************************************************
227 * Return the ordinal, name, and type info corresponding to a CS:IP address.
229 static const CALLFROM16 *get_entry_point( STACK16FRAME *frame, LPSTR module, LPSTR func, WORD *pOrd )
237 if (!(pModule = NE_GetPtr( FarGetOwner16( GlobalHandle16( frame->module_cs ) ))))
242 bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule->entry_table);
245 entry = (ET_ENTRY *)((BYTE *)bundle+6);
246 for (i = bundle->first + 1; i <= bundle->last; i++)
248 if ((entry->offs < frame->entry_ip)
249 && (entry->segnum == 1) /* code segment ? */
250 && (entry->offs >= max_offset))
252 max_offset = entry->offs;
257 } while ( (bundle->next)
258 && (bundle = (ET_BUNDLE *)((BYTE *)pModule+bundle->next)));
260 /* Search for the name in the resident names table */
261 /* (built-in modules have no non-resident table) */
263 p = (BYTE *)pModule + pModule->name_table;
264 memcpy( module, p + 1, *p );
269 p += *p + 1 + sizeof(WORD);
270 if (*(WORD *)(p + *p + 1) == *pOrd) break;
272 memcpy( func, p + 1, *p );
275 /* Retrieve entry point call structure */
276 p = MapSL( MAKESEGPTR( frame->module_cs, frame->callfrom_ip ) );
277 /* p now points to lret, get the start of CALLFROM16 structure */
278 return (CALLFROM16 *)(p - (BYTE *)&((CALLFROM16 *)0)->lret);
282 /***********************************************************************
283 * RELAY_DebugCallFrom16
285 void RELAY_DebugCallFrom16( CONTEXT86 *context )
289 char *args16, module[10], func[64];
290 const CALLFROM16 *call;
293 if (!TRACE_ON(relay)) return;
295 frame = CURRENT_STACK16;
296 call = get_entry_point( frame, module, func, &ordinal );
297 if (!call) return; /* happens for the two snoop register relays */
298 if (!RELAY_ShowDebugmsgRelay( module, ordinal, func )) return;
299 DPRINTF( "%04lx:Call %s.%d: %s(",GetCurrentThreadId(), module, ordinal, func );
300 args16 = (char *)(frame + 1);
302 if (call->lret == 0xcb66) /* cdecl */
304 for (i = 0; i < 20; i++)
306 int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
308 if (type == ARG_NONE) break;
309 if (i) DPRINTF( "," );
314 DPRINTF( "%04x", *(WORD *)args16 );
315 args16 += sizeof(WORD);
318 DPRINTF( "%08x", *(int *)args16 );
319 args16 += sizeof(int);
322 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
323 args16 += sizeof(SEGPTR);
326 DPRINTF( "%08x %s", *(int *)args16,
327 debugstr_a( MapSL(*(SEGPTR *)args16 )));
328 args16 += sizeof(int);
331 DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16,
332 debugstr_a( MapSL(*(SEGPTR *)args16 )) );
333 args16 += sizeof(SEGPTR);
342 /* Start with the last arg */
343 args16 += call->nArgs;
344 for (i = 0; i < 20; i++)
346 int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
348 if (type == ARG_NONE) break;
349 if (i) DPRINTF( "," );
354 args16 -= sizeof(WORD);
355 DPRINTF( "%04x", *(WORD *)args16 );
358 args16 -= sizeof(int);
359 DPRINTF( "%08x", *(int *)args16 );
362 args16 -= sizeof(SEGPTR);
363 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
366 args16 -= sizeof(int);
367 DPRINTF( "%08x %s", *(int *)args16,
368 debugstr_a( MapSL(*(SEGPTR *)args16 )));
371 args16 -= sizeof(SEGPTR);
372 DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16,
373 debugstr_a( MapSL(*(SEGPTR *)args16 )) );
381 DPRINTF( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
383 if (call->arg_types[0] & ARG_REGISTER)
384 DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
385 (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
386 (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
387 (WORD)context->SegEs, context->EFlags );
389 SYSLEVEL_CheckNotLevel( 2 );
393 /***********************************************************************
394 * RELAY_DebugCallFrom16Ret
396 void RELAY_DebugCallFrom16Ret( CONTEXT86 *context, int ret_val )
400 char module[10], func[64];
401 const CALLFROM16 *call;
403 if (!TRACE_ON(relay)) return;
404 frame = CURRENT_STACK16;
405 call = get_entry_point( frame, module, func, &ordinal );
407 if (!RELAY_ShowDebugmsgRelay( module, ordinal, func )) return;
408 DPRINTF( "%04lx:Ret %s.%d: %s() ", GetCurrentThreadId(), module, ordinal, func );
410 if (call->arg_types[0] & ARG_REGISTER)
412 DPRINTF("retval=none ret=%04x:%04x ds=%04x\n",
413 (WORD)context->SegCs, LOWORD(context->Eip), (WORD)context->SegDs);
414 DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
415 (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
416 (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
417 (WORD)context->SegEs, context->EFlags );
419 else if (call->arg_types[0] & ARG_RET16)
421 DPRINTF( "retval=%04x ret=%04x:%04x ds=%04x\n",
422 ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
426 DPRINTF( "retval=%08x ret=%04x:%04x ds=%04x\n",
427 ret_val, frame->cs, frame->ip, frame->ds );
429 SYSLEVEL_CheckNotLevel( 2 );
435 * Stubs for the CallTo16/CallFrom16 routines on non-Intel architectures
436 * (these will never be called but need to be present to satisfy the linker ...)
439 /***********************************************************************
440 * __wine_call_from_16_word (KERNEL32.@)
442 WORD __wine_call_from_16_word()
447 /***********************************************************************
448 * __wine_call_from_16_long (KERNEL32.@)
450 LONG __wine_call_from_16_long()
455 /***********************************************************************
456 * __wine_call_from_16_regs (KERNEL32.@)
458 void __wine_call_from_16_regs()
463 DWORD WINAPI CALL32_CBClient( FARPROC proc, LPWORD args, DWORD *esi )
466 DWORD WINAPI CALL32_CBClientEx( FARPROC proc, LPWORD args, DWORD *esi, INT *nArgs )
469 #endif /* __i386__ */