gdiplus: Add few TRACE(..) for Matrix.
[wine] / dlls / ntdll / relay.c
1 /*
2  * Win32 relay and snoop functions
3  *
4  * Copyright 1997 Alexandre Julliard
5  * Copyright 1998 Marcus Meissner
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winternl.h"
34 #include "wine/exception.h"
35 #include "ntdll_misc.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(relay);
40
41 #ifdef __i386__
42
43 WINE_DECLARE_DEBUG_CHANNEL(snoop);
44 WINE_DECLARE_DEBUG_CHANNEL(seh);
45
46 struct relay_descr  /* descriptor for a module */
47 {
48     void               *magic;               /* signature */
49     void               *relay_from_32;       /* functions to call from relay thunks */
50     void               *relay_from_32_regs;
51     void               *private;             /* reserved for the relay code private data */
52     const char         *entry_point_base;    /* base address of entry point thunks */
53     const unsigned int *entry_point_offsets; /* offsets of entry points thunks */
54     const unsigned int *arg_types;           /* table of argument types for all entry points */
55 };
56
57 #define RELAY_DESCR_MAGIC  ((void *)0xdeb90001)
58
59 /* private data built at dll load time */
60
61 struct relay_entry_point
62 {
63     void       *orig_func;    /* original entry point function */
64     const char *name;         /* function name (if any) */
65 };
66
67 struct relay_private_data
68 {
69     HMODULE                  module;            /* module handle of this dll */
70     unsigned int             base;              /* ordinal base */
71     char                     dllname[40];       /* dll name (without .dll extension) */
72     struct relay_entry_point entry_points[1];   /* list of dll entry points */
73 };
74
75 static const WCHAR **debug_relay_excludelist;
76 static const WCHAR **debug_relay_includelist;
77 static const WCHAR **debug_snoop_excludelist;
78 static const WCHAR **debug_snoop_includelist;
79 static const WCHAR **debug_from_relay_excludelist;
80 static const WCHAR **debug_from_relay_includelist;
81 static const WCHAR **debug_from_snoop_excludelist;
82 static const WCHAR **debug_from_snoop_includelist;
83
84 static BOOL init_done;
85
86 /* compare an ASCII and a Unicode string without depending on the current codepage */
87 static inline int strcmpAW( const char *strA, const WCHAR *strW )
88 {
89     while (*strA && ((unsigned char)*strA == *strW)) { strA++; strW++; }
90     return (unsigned char)*strA - *strW;
91 }
92
93 /* compare an ASCII and a Unicode string without depending on the current codepage */
94 static inline int strncmpiAW( const char *strA, const WCHAR *strW, int n )
95 {
96     int ret = 0;
97     for ( ; n > 0; n--, strA++, strW++)
98         if ((ret = toupperW((unsigned char)*strA) - toupperW(*strW)) || !*strA) break;
99     return ret;
100 }
101
102 /***********************************************************************
103  *           build_list
104  *
105  * Build a function list from a ';'-separated string.
106  */
107 static const WCHAR **build_list( const WCHAR *buffer )
108 {
109     int count = 1;
110     const WCHAR *p = buffer;
111     const WCHAR **ret;
112
113     while ((p = strchrW( p, ';' )))
114     {
115         count++;
116         p++;
117     }
118     /* allocate count+1 pointers, plus the space for a copy of the string */
119     if ((ret = RtlAllocateHeap( GetProcessHeap(), 0,
120                                 (count+1) * sizeof(WCHAR*) + (strlenW(buffer)+1) * sizeof(WCHAR) )))
121     {
122         WCHAR *str = (WCHAR *)(ret + count + 1);
123         WCHAR *p = str;
124
125         strcpyW( str, buffer );
126         count = 0;
127         for (;;)
128         {
129             ret[count++] = p;
130             if (!(p = strchrW( p, ';' ))) break;
131             *p++ = 0;
132         }
133         ret[count++] = NULL;
134     }
135     return ret;
136 }
137
138 /***********************************************************************
139  *           load_list_value
140  *
141  * Load a function list from a registry value.
142  */
143 static const WCHAR **load_list( HKEY hkey, const WCHAR *value )
144 {
145     char initial_buffer[4096];
146     char *buffer = initial_buffer;
147     DWORD count;
148     NTSTATUS status;
149     UNICODE_STRING name;
150     const WCHAR **list = NULL;
151
152     RtlInitUnicodeString( &name, value );
153     status = NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count );
154     if (status == STATUS_BUFFER_OVERFLOW)
155     {
156         buffer = RtlAllocateHeap( GetProcessHeap(), 0, count );
157         status = NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, count, &count );
158     }
159     if (status == STATUS_SUCCESS)
160     {
161         WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)buffer)->Data;
162         list = build_list( str );
163         if (list) TRACE( "%s = %s\n", debugstr_w(value), debugstr_w(str) );
164     }
165
166     if (buffer != initial_buffer) RtlFreeHeap( GetProcessHeap(), 0, buffer );
167     return list;
168 }
169
170 /***********************************************************************
171  *           init_debug_lists
172  *
173  * Build the relay include/exclude function lists.
174  */
175 static void init_debug_lists(void)
176 {
177     OBJECT_ATTRIBUTES attr;
178     UNICODE_STRING name;
179     HANDLE root, hkey;
180     static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\',
181                                     'W','i','n','e','\\',
182                                     'D','e','b','u','g',0};
183     static const WCHAR RelayIncludeW[] = {'R','e','l','a','y','I','n','c','l','u','d','e',0};
184     static const WCHAR RelayExcludeW[] = {'R','e','l','a','y','E','x','c','l','u','d','e',0};
185     static const WCHAR SnoopIncludeW[] = {'S','n','o','o','p','I','n','c','l','u','d','e',0};
186     static const WCHAR SnoopExcludeW[] = {'S','n','o','o','p','E','x','c','l','u','d','e',0};
187     static const WCHAR RelayFromIncludeW[] = {'R','e','l','a','y','F','r','o','m','I','n','c','l','u','d','e',0};
188     static const WCHAR RelayFromExcludeW[] = {'R','e','l','a','y','F','r','o','m','E','x','c','l','u','d','e',0};
189     static const WCHAR SnoopFromIncludeW[] = {'S','n','o','o','p','F','r','o','m','I','n','c','l','u','d','e',0};
190     static const WCHAR SnoopFromExcludeW[] = {'S','n','o','o','p','F','r','o','m','E','x','c','l','u','d','e',0};
191
192     if (init_done) return;
193     init_done = TRUE;
194
195     RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
196     attr.Length = sizeof(attr);
197     attr.RootDirectory = root;
198     attr.ObjectName = &name;
199     attr.Attributes = 0;
200     attr.SecurityDescriptor = NULL;
201     attr.SecurityQualityOfService = NULL;
202     RtlInitUnicodeString( &name, configW );
203
204     /* @@ Wine registry key: HKCU\Software\Wine\Debug */
205     if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) hkey = 0;
206     NtClose( root );
207     if (!hkey) return;
208
209     debug_relay_includelist = load_list( hkey, RelayIncludeW );
210     debug_relay_excludelist = load_list( hkey, RelayExcludeW );
211     debug_snoop_includelist = load_list( hkey, SnoopIncludeW );
212     debug_snoop_excludelist = load_list( hkey, SnoopExcludeW );
213     debug_from_relay_includelist = load_list( hkey, RelayFromIncludeW );
214     debug_from_relay_excludelist = load_list( hkey, RelayFromExcludeW );
215     debug_from_snoop_includelist = load_list( hkey, SnoopFromIncludeW );
216     debug_from_snoop_excludelist = load_list( hkey, SnoopFromExcludeW );
217
218     NtClose( hkey );
219 }
220
221
222 /***********************************************************************
223  *           check_list
224  *
225  * Check if a given module and function is in the list.
226  */
227 static BOOL check_list( const char *module, int ordinal, const char *func, const WCHAR *const *list )
228 {
229     char ord_str[10];
230
231     sprintf( ord_str, "%d", ordinal );
232     for(; *list; list++)
233     {
234         const WCHAR *p = strrchrW( *list, '.' );
235         if (p && p > *list)  /* check module and function */
236         {
237             int len = p - *list;
238             if (strncmpiAW( module, *list, len-1 ) || module[len]) continue;
239             if (p[1] == '*' && !p[2]) return TRUE;
240             if (!strcmpAW( ord_str, p + 1 )) return TRUE;
241             if (func && !strcmpAW( func, p + 1 )) return TRUE;
242         }
243         else  /* function only */
244         {
245             if (func && !strcmpAW( func, *list )) return TRUE;
246         }
247     }
248     return FALSE;
249 }
250
251
252 /***********************************************************************
253  *           check_relay_include
254  *
255  * Check if a given function must be included in the relay output.
256  */
257 static BOOL check_relay_include( const char *module, int ordinal, const char *func )
258 {
259     if (debug_relay_excludelist && check_list( module, ordinal, func, debug_relay_excludelist ))
260         return FALSE;
261     if (debug_relay_includelist && !check_list( module, ordinal, func, debug_relay_includelist ))
262         return FALSE;
263     return TRUE;
264 }
265
266 /***********************************************************************
267  *           check_from_module
268  *
269  * Check if calls from a given module must be included in the relay/snoop output,
270  * given the exclusion and inclusion lists.
271  */
272 static BOOL check_from_module( const WCHAR **includelist, const WCHAR **excludelist, const WCHAR *module )
273 {
274     static const WCHAR dllW[] = {'.','d','l','l',0 };
275     const WCHAR **listitem;
276     BOOL show;
277
278     if (!module) return TRUE;
279     if (!includelist && !excludelist) return TRUE;
280     if (excludelist)
281     {
282         show = TRUE;
283         listitem = excludelist;
284     }
285     else
286     {
287         show = FALSE;
288         listitem = includelist;
289     }
290     for(; *listitem; listitem++)
291     {
292         int len;
293
294         if (!strcmpiW( *listitem, module )) return !show;
295         len = strlenW( *listitem );
296         if (!strncmpiW( *listitem, module, len ) && !strcmpiW( module + len, dllW ))
297             return !show;
298     }
299     return show;
300 }
301
302 /***********************************************************************
303  *           RELAY_PrintArgs
304  */
305 static inline void RELAY_PrintArgs( const int *args, int nb_args, unsigned int typemask )
306 {
307     while (nb_args--)
308     {
309         if ((typemask & 3) && HIWORD(*args))
310         {
311             if (typemask & 2)
312                 DPRINTF( "%08x %s", *args, debugstr_w((LPCWSTR)*args) );
313             else
314                 DPRINTF( "%08x %s", *args, debugstr_a((LPCSTR)*args) );
315         }
316         else DPRINTF( "%08x", *args );
317         if (nb_args) DPRINTF( "," );
318         args++;
319         typemask >>= 2;
320     }
321 }
322
323 extern LONGLONG call_entry_point( void *func, int nb_args, const int *args );
324 __ASM_GLOBAL_FUNC( call_entry_point,
325                    "\tpushl %ebp\n"
326                    "\tmovl %esp,%ebp\n"
327                    "\tpushl %esi\n"
328                    "\tpushl %edi\n"
329                    "\tmovl 12(%ebp),%edx\n"
330                    "\tshll $2,%edx\n"
331                    "\tjz 1f\n"
332                    "\tsubl %edx,%esp\n"
333                    "\tandl $~15,%esp\n"
334                    "\tmovl 12(%ebp),%ecx\n"
335                    "\tmovl 16(%ebp),%esi\n"
336                    "\tmovl %esp,%edi\n"
337                    "\tcld\n"
338                    "\trep; movsl\n"
339                    "1:\tcall *8(%ebp)\n"
340                    "\tleal -8(%ebp),%esp\n"
341                    "\tpopl %edi\n"
342                    "\tpopl %esi\n"
343                    "\tpopl %ebp\n"
344                    "\tret" )
345
346
347 /***********************************************************************
348  *           relay_call_from_32
349  *
350  * stack points to the return address, i.e. the first argument is stack[1].
351  */
352 static LONGLONG WINAPI relay_call_from_32( struct relay_descr *descr, unsigned int idx, const int *stack )
353 {
354     LONGLONG ret;
355     WORD ordinal = LOWORD(idx);
356     BYTE nb_args = LOBYTE(HIWORD(idx));
357     BYTE flags   = HIBYTE(HIWORD(idx));
358     struct relay_private_data *data = descr->private;
359     struct relay_entry_point *entry_point = data->entry_points + ordinal;
360
361     if (!TRACE_ON(relay))
362         ret = call_entry_point( entry_point->orig_func, nb_args, stack + 1 );
363     else
364     {
365         if (entry_point->name)
366             DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
367         else
368             DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
369         RELAY_PrintArgs( stack + 1, nb_args, descr->arg_types[ordinal] );
370         DPRINTF( ") ret=%08x\n", stack[0] );
371
372         ret = call_entry_point( entry_point->orig_func, nb_args, stack + 1 );
373
374         if (entry_point->name)
375             DPRINTF( "%04x:Ret  %s.%s()", GetCurrentThreadId(), data->dllname, entry_point->name );
376         else
377             DPRINTF( "%04x:Ret  %s.%u()", GetCurrentThreadId(), data->dllname, data->base + ordinal );
378
379         if (flags & 1)  /* 64-bit return value */
380             DPRINTF( " retval=%08x%08x ret=%08x\n",
381                      (UINT)(ret >> 32), (UINT)ret, stack[0] );
382         else
383             DPRINTF( " retval=%08x ret=%08x\n", (UINT)ret, stack[0] );
384     }
385     return ret;
386 }
387
388
389 /***********************************************************************
390  *           relay_call_from_32_regs
391  */
392 void WINAPI __regs_relay_call_from_32_regs( struct relay_descr *descr, unsigned int idx,
393                                             unsigned int orig_eax, unsigned int ret_addr,
394                                             CONTEXT86 *context )
395 {
396     WORD ordinal = LOWORD(idx);
397     BYTE nb_args = LOBYTE(HIWORD(idx));
398     BYTE flags   = HIBYTE(HIWORD(idx));
399     struct relay_private_data *data = descr->private;
400     struct relay_entry_point *entry_point = data->entry_points + ordinal;
401     BYTE *orig_func = entry_point->orig_func;
402     int *args = (int *)context->Esp;
403     int args_copy[32];
404
405     /* restore the context to what it was before the relay thunk */
406     context->Eax = orig_eax;
407     context->Eip = ret_addr;
408     if (flags & 2)  /* stdcall */
409         context->Esp += nb_args * sizeof(int);
410
411     if (TRACE_ON(relay))
412     {
413         if (entry_point->name)
414             DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
415         else
416             DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
417         RELAY_PrintArgs( args, nb_args, descr->arg_types[ordinal] );
418         DPRINTF( ") ret=%08x\n", ret_addr );
419
420         DPRINTF( "%04x:  eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
421                  "ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
422                  GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
423                  context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
424                  context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
425
426         assert( orig_func[0] == 0x50 /* pushl %eax */ );
427         assert( orig_func[1] == 0xe8 /* call */ );
428     }
429
430     /* now call the real function */
431
432     memcpy( args_copy, args, nb_args * sizeof(args[0]) );
433     args_copy[nb_args++] = (int)context;  /* append context argument */
434
435     call_entry_point( orig_func + 6 + *(int *)(orig_func + 6), nb_args, args_copy );
436
437
438     if (TRACE_ON(relay))
439     {
440         if (entry_point->name)
441             DPRINTF( "%04x:Ret  %s.%s() retval=%08x ret=%08x\n",
442                      GetCurrentThreadId(), data->dllname, entry_point->name,
443                      context->Eax, context->Eip );
444         else
445             DPRINTF( "%04x:Ret  %s.%u() retval=%08x ret=%08x\n",
446                      GetCurrentThreadId(), data->dllname, data->base + ordinal,
447                      context->Eax, context->Eip );
448         DPRINTF( "%04x:  eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
449                  "ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
450                  GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
451                  context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
452                  context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
453     }
454 }
455 extern void WINAPI relay_call_from_32_regs(void);
456 DEFINE_REGS_ENTRYPOINT( relay_call_from_32_regs, 16, 16 )
457
458
459 /***********************************************************************
460  *           RELAY_GetProcAddress
461  *
462  * Return the proc address to use for a given function.
463  */
464 FARPROC RELAY_GetProcAddress( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
465                               DWORD exp_size, FARPROC proc, DWORD ordinal, const WCHAR *user )
466 {
467     struct relay_private_data *data;
468     const struct relay_descr *descr = (const struct relay_descr *)((const char *)exports + exp_size);
469
470     if (descr->magic != RELAY_DESCR_MAGIC || !(data = descr->private)) return proc;  /* no relay data */
471     if (!data->entry_points[ordinal].orig_func) return proc;  /* not a relayed function */
472     if (check_from_module( debug_from_relay_includelist, debug_from_relay_excludelist, user ))
473         return proc;  /* we want to relay it */
474     return data->entry_points[ordinal].orig_func;
475 }
476
477
478 /***********************************************************************
479  *           RELAY_SetupDLL
480  *
481  * Setup relay debugging for a built-in dll.
482  */
483 void RELAY_SetupDLL( HMODULE module )
484 {
485     IMAGE_EXPORT_DIRECTORY *exports;
486     DWORD *funcs;
487     unsigned int i, len;
488     DWORD size, entry_point_rva;
489     struct relay_descr *descr;
490     struct relay_private_data *data;
491     const WORD *ordptr;
492
493     if (!init_done) init_debug_lists();
494
495     exports = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size );
496     if (!exports) return;
497
498     descr = (struct relay_descr *)((char *)exports + size);
499     if (descr->magic != RELAY_DESCR_MAGIC) return;
500
501     if (!(data = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data) +
502                                   (exports->NumberOfFunctions-1) * sizeof(data->entry_points) )))
503         return;
504
505     descr->relay_from_32 = relay_call_from_32;
506     descr->relay_from_32_regs = relay_call_from_32_regs;
507     descr->private = data;
508
509     data->module = module;
510     data->base   = exports->Base;
511     len = strlen( (char *)module + exports->Name );
512     if (len > 4 && !strcasecmp( (char *)module + exports->Name + len - 4, ".dll" )) len -= 4;
513     len = min( len, sizeof(data->dllname) - 1 );
514     memcpy( data->dllname, (char *)module + exports->Name, len );
515     data->dllname[len] = 0;
516
517     /* fetch name pointer for all entry points and store them in the private structure */
518
519     ordptr = (const WORD *)((char *)module + exports->AddressOfNameOrdinals);
520     for (i = 0; i < exports->NumberOfNames; i++, ordptr++)
521     {
522         DWORD name_rva = ((DWORD*)((char *)module + exports->AddressOfNames))[i];
523         data->entry_points[*ordptr].name = (const char *)module + name_rva;
524     }
525
526     /* patch the functions in the export table to point to the relay thunks */
527
528     funcs = (DWORD *)((char *)module + exports->AddressOfFunctions);
529     entry_point_rva = descr->entry_point_base - (const char *)module;
530     for (i = 0; i < exports->NumberOfFunctions; i++, funcs++)
531     {
532         if (!descr->entry_point_offsets[i]) continue;   /* not a normal function */
533         if (!check_relay_include( data->dllname, i + exports->Base, data->entry_points[i].name ))
534             continue;  /* don't include this entry point */
535
536         data->entry_points[i].orig_func = (char *)module + *funcs;
537         *funcs = entry_point_rva + descr->entry_point_offsets[i];
538     }
539 }
540
541
542
543 /***********************************************************************/
544 /* snoop support */
545 /***********************************************************************/
546
547 #include "pshpack1.h"
548
549 typedef struct
550 {
551         /* code part */
552         BYTE            lcall;          /* 0xe8 call snoopentry (relative) */
553         /* NOTE: If you move snoopentry OR nrofargs fix the relative offset
554          * calculation!
555          */
556         DWORD           snoopentry;     /* SNOOP_Entry relative */
557         /* unreached */
558         int             nrofargs;
559         FARPROC origfun;
560         const char *name;
561 } SNOOP_FUN;
562
563 typedef struct tagSNOOP_DLL {
564         HMODULE hmod;
565         SNOOP_FUN       *funs;
566         DWORD           ordbase;
567         DWORD           nrofordinals;
568         struct tagSNOOP_DLL     *next;
569         char name[1];
570 } SNOOP_DLL;
571
572 typedef struct
573 {
574         /* code part */
575         BYTE            lcall;          /* 0xe8 call snoopret relative*/
576         /* NOTE: If you move snoopret OR origreturn fix the relative offset
577          * calculation!
578          */
579         DWORD           snoopret;       /* SNOOP_Ret relative */
580         /* unreached */
581         FARPROC origreturn;
582         SNOOP_DLL       *dll;
583         DWORD           ordinal;
584         DWORD           origESP;
585         DWORD           *args;          /* saved args across a stdcall */
586 } SNOOP_RETURNENTRY;
587
588 typedef struct tagSNOOP_RETURNENTRIES {
589         SNOOP_RETURNENTRY entry[4092/sizeof(SNOOP_RETURNENTRY)];
590         struct tagSNOOP_RETURNENTRIES   *next;
591 } SNOOP_RETURNENTRIES;
592
593 #include "poppack.h"
594
595 extern void WINAPI SNOOP_Entry(void);
596 extern void WINAPI SNOOP_Return(void);
597
598 static SNOOP_DLL *firstdll;
599 static SNOOP_RETURNENTRIES *firstrets;
600
601
602 /***********************************************************************
603  *          SNOOP_ShowDebugmsgSnoop
604  *
605  * Simple function to decide if a particular debugging message is
606  * wanted.
607  */
608 static BOOL SNOOP_ShowDebugmsgSnoop(const char *module, int ordinal, const char *func)
609 {
610     if (debug_snoop_excludelist && check_list( module, ordinal, func, debug_snoop_excludelist ))
611         return FALSE;
612     if (debug_snoop_includelist && !check_list( module, ordinal, func, debug_snoop_includelist ))
613         return FALSE;
614     return TRUE;
615 }
616
617
618 /***********************************************************************
619  *           SNOOP_SetupDLL
620  *
621  * Setup snoop debugging for a native dll.
622  */
623 void SNOOP_SetupDLL(HMODULE hmod)
624 {
625     SNOOP_DLL **dll = &firstdll;
626     char *p, *name;
627     void *addr;
628     SIZE_T size;
629     ULONG size32;
630     IMAGE_EXPORT_DIRECTORY *exports;
631
632     if (!init_done) init_debug_lists();
633
634     exports = RtlImageDirectoryEntryToData( hmod, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size32 );
635     if (!exports || !exports->NumberOfFunctions) return;
636     name = (char *)hmod + exports->Name;
637     size = size32;
638
639     TRACE_(snoop)("hmod=%p, name=%s\n", hmod, name);
640
641     while (*dll) {
642         if ((*dll)->hmod == hmod)
643         {
644             /* another dll, loaded at the same address */
645             addr = (*dll)->funs;
646             size = (*dll)->nrofordinals * sizeof(SNOOP_FUN);
647             NtFreeVirtualMemory(NtCurrentProcess(), &addr, &size, MEM_RELEASE);
648             break;
649         }
650         dll = &((*dll)->next);
651     }
652     if (*dll)
653         *dll = RtlReAllocateHeap(GetProcessHeap(),
654                              HEAP_ZERO_MEMORY, *dll,
655                              sizeof(SNOOP_DLL) + strlen(name));
656     else
657         *dll = RtlAllocateHeap(GetProcessHeap(),
658                              HEAP_ZERO_MEMORY,
659                              sizeof(SNOOP_DLL) + strlen(name));
660     (*dll)->hmod        = hmod;
661     (*dll)->ordbase = exports->Base;
662     (*dll)->nrofordinals = exports->NumberOfFunctions;
663     strcpy( (*dll)->name, name );
664     p = (*dll)->name + strlen((*dll)->name) - 4;
665     if (p > (*dll)->name && !strcasecmp( p, ".dll" )) *p = 0;
666
667     size = exports->NumberOfFunctions * sizeof(SNOOP_FUN);
668     addr = NULL;
669     NtAllocateVirtualMemory(NtCurrentProcess(), &addr, 0, &size,
670                             MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
671     if (!addr) {
672         RtlFreeHeap(GetProcessHeap(),0,*dll);
673         FIXME("out of memory\n");
674         return;
675     }
676     (*dll)->funs = addr;
677     memset((*dll)->funs,0,size);
678 }
679
680
681 /***********************************************************************
682  *           SNOOP_GetProcAddress
683  *
684  * Return the proc address to use for a given function.
685  */
686 FARPROC SNOOP_GetProcAddress( HMODULE hmod, const IMAGE_EXPORT_DIRECTORY *exports,
687                               DWORD exp_size, FARPROC origfun, DWORD ordinal,
688                               const WCHAR *user)
689 {
690     unsigned int i;
691     const char *ename;
692     const WORD *ordinals;
693     const DWORD *names;
694     SNOOP_DLL *dll = firstdll;
695     SNOOP_FUN *fun;
696     const IMAGE_SECTION_HEADER *sec;
697
698     if (!TRACE_ON(snoop)) return origfun;
699     if (!check_from_module( debug_from_snoop_includelist, debug_from_snoop_excludelist, user ))
700         return origfun; /* the calling module was explicitly excluded */
701
702     if (!*(LPBYTE)origfun) /* 0x00 is an impossible opcode, possible dataref. */
703         return origfun;
704
705     sec = RtlImageRvaToSection( RtlImageNtHeader(hmod), hmod, (char *)origfun - (char *)hmod );
706
707     if (!sec || !(sec->Characteristics & IMAGE_SCN_CNT_CODE))
708         return origfun;  /* most likely a data reference */
709
710     while (dll) {
711         if (hmod == dll->hmod)
712             break;
713         dll = dll->next;
714     }
715     if (!dll)   /* probably internal */
716         return origfun;
717
718     /* try to find a name for it */
719     ename = NULL;
720     names = (const DWORD *)((const char *)hmod + exports->AddressOfNames);
721     ordinals = (const WORD *)((const char *)hmod + exports->AddressOfNameOrdinals);
722     if (names) for (i = 0; i < exports->NumberOfNames; i++)
723     {
724         if (ordinals[i] == ordinal)
725         {
726             ename = (const char *)hmod + names[i];
727             break;
728         }
729     }
730     if (!SNOOP_ShowDebugmsgSnoop(dll->name,ordinal,ename))
731         return origfun;
732     assert(ordinal < dll->nrofordinals);
733     fun = dll->funs + ordinal;
734     if (!fun->name)
735     {
736         fun->name       = ename;
737         fun->lcall      = 0xe8;
738         /* NOTE: origreturn struct member MUST come directly after snoopentry */
739         fun->snoopentry = (char*)SNOOP_Entry-((char*)(&fun->nrofargs));
740         fun->origfun    = origfun;
741         fun->nrofargs   = -1;
742     }
743     return (FARPROC)&(fun->lcall);
744 }
745
746 static void SNOOP_PrintArg(DWORD x)
747 {
748     int i,nostring;
749
750     DPRINTF("%08x",x);
751     if (!HIWORD(x) || TRACE_ON(seh)) return; /* trivial reject to avoid faults */
752     __TRY
753     {
754         LPBYTE s=(LPBYTE)x;
755         i=0;nostring=0;
756         while (i<80) {
757             if (s[i]==0) break;
758             if (s[i]<0x20) {nostring=1;break;}
759             if (s[i]>=0x80) {nostring=1;break;}
760             i++;
761         }
762         if (!nostring && i > 5)
763             DPRINTF(" %s",debugstr_an((LPSTR)x,i));
764         else  /* try unicode */
765         {
766             LPWSTR s=(LPWSTR)x;
767             i=0;nostring=0;
768             while (i<80) {
769                 if (s[i]==0) break;
770                 if (s[i]<0x20) {nostring=1;break;}
771                 if (s[i]>0x100) {nostring=1;break;}
772                 i++;
773             }
774             if (!nostring && i > 5) DPRINTF(" %s",debugstr_wn((LPWSTR)x,i));
775         }
776     }
777     __EXCEPT_PAGE_FAULT
778     {
779     }
780     __ENDTRY
781 }
782
783 #define CALLER1REF (*(DWORD*)context->Esp)
784
785 void WINAPI __regs_SNOOP_Entry( CONTEXT86 *context )
786 {
787         DWORD           ordinal=0,entry = context->Eip - 5;
788         SNOOP_DLL       *dll = firstdll;
789         SNOOP_FUN       *fun = NULL;
790         SNOOP_RETURNENTRIES     **rets = &firstrets;
791         SNOOP_RETURNENTRY       *ret;
792         int             i=0, max;
793
794         while (dll) {
795                 if (    ((char*)entry>=(char*)dll->funs)        &&
796                         ((char*)entry<=(char*)(dll->funs+dll->nrofordinals))
797                 ) {
798                         fun = (SNOOP_FUN*)entry;
799                         ordinal = fun-dll->funs;
800                         break;
801                 }
802                 dll=dll->next;
803         }
804         if (!dll) {
805                 FIXME("entrypoint 0x%08x not found\n",entry);
806                 return; /* oops */
807         }
808         /* guess cdecl ... */
809         if (fun->nrofargs<0) {
810                 /* Typical cdecl return frame is:
811                  *     add esp, xxxxxxxx
812                  * which has (for xxxxxxxx up to 255 the opcode "83 C4 xx".
813                  * (after that 81 C2 xx xx xx xx)
814                  */
815                 LPBYTE  reteip = (LPBYTE)CALLER1REF;
816
817                 if (reteip) {
818                         if ((reteip[0]==0x83)&&(reteip[1]==0xc4))
819                                 fun->nrofargs=reteip[2]/4;
820                 }
821         }
822
823
824         while (*rets) {
825                 for (i=0;i<sizeof((*rets)->entry)/sizeof((*rets)->entry[0]);i++)
826                         if (!(*rets)->entry[i].origreturn)
827                                 break;
828                 if (i!=sizeof((*rets)->entry)/sizeof((*rets)->entry[0]))
829                         break;
830                 rets = &((*rets)->next);
831         }
832         if (!*rets) {
833                 SIZE_T size = 4096;
834                 VOID* addr = NULL;
835
836                 NtAllocateVirtualMemory(NtCurrentProcess(), &addr, 0, &size, 
837                                         MEM_COMMIT | MEM_RESERVE,
838                                         PAGE_EXECUTE_READWRITE);
839                 if (!addr) return;
840                 *rets = addr;
841                 memset(*rets,0,4096);
842                 i = 0;  /* entry 0 is free */
843         }
844         ret = &((*rets)->entry[i]);
845         ret->lcall      = 0xe8;
846         /* NOTE: origreturn struct member MUST come directly after snoopret */
847         ret->snoopret   = ((char*)SNOOP_Return)-(char*)(&ret->origreturn);
848         ret->origreturn = (FARPROC)CALLER1REF;
849         CALLER1REF      = (DWORD)&ret->lcall;
850         ret->dll        = dll;
851         ret->args       = NULL;
852         ret->ordinal    = ordinal;
853         ret->origESP    = context->Esp;
854
855         context->Eip = (DWORD)fun->origfun;
856
857         if (fun->name) DPRINTF("%04x:CALL %s.%s(",GetCurrentThreadId(),dll->name,fun->name);
858         else DPRINTF("%04x:CALL %s.%d(",GetCurrentThreadId(),dll->name,dll->ordbase+ordinal);
859         if (fun->nrofargs>0) {
860                 max = fun->nrofargs; if (max>16) max=16;
861                 for (i=0;i<max;i++)
862                 {
863                     SNOOP_PrintArg(*(DWORD*)(context->Esp + 4 + sizeof(DWORD)*i));
864                     if (i<fun->nrofargs-1) DPRINTF(",");
865                 }
866                 if (max!=fun->nrofargs)
867                         DPRINTF(" ...");
868         } else if (fun->nrofargs<0) {
869                 DPRINTF("<unknown, check return>");
870                 ret->args = RtlAllocateHeap(GetProcessHeap(),
871                                             0,16*sizeof(DWORD));
872                 memcpy(ret->args,(LPBYTE)(context->Esp + 4),sizeof(DWORD)*16);
873         }
874         DPRINTF(") ret=%08x\n",(DWORD)ret->origreturn);
875 }
876
877
878 void WINAPI __regs_SNOOP_Return( CONTEXT86 *context )
879 {
880         SNOOP_RETURNENTRY       *ret = (SNOOP_RETURNENTRY*)(context->Eip - 5);
881         SNOOP_FUN *fun = &ret->dll->funs[ret->ordinal];
882
883         /* We haven't found out the nrofargs yet. If we called a cdecl
884          * function it is too late anyway and we can just set '0' (which
885          * will be the difference between orig and current ESP
886          * If stdcall -> everything ok.
887          */
888         if (ret->dll->funs[ret->ordinal].nrofargs<0)
889                 ret->dll->funs[ret->ordinal].nrofargs=(context->Esp - ret->origESP-4)/4;
890         context->Eip = (DWORD)ret->origreturn;
891         if (ret->args) {
892                 int     i,max;
893
894                 if (fun->name)
895                     DPRINTF("%04x:RET  %s.%s(", GetCurrentThreadId(), ret->dll->name, fun->name);
896                 else
897                     DPRINTF("%04x:RET  %s.%d(", GetCurrentThreadId(),
898                             ret->dll->name,ret->dll->ordbase+ret->ordinal);
899
900                 max = fun->nrofargs;
901                 if (max>16) max=16;
902
903                 for (i=0;i<max;i++)
904                 {
905                     SNOOP_PrintArg(ret->args[i]);
906                     if (i<max-1) DPRINTF(",");
907                 }
908                 DPRINTF(") retval=%08x ret=%08x\n",
909                         context->Eax,(DWORD)ret->origreturn );
910                 RtlFreeHeap(GetProcessHeap(),0,ret->args);
911                 ret->args = NULL;
912         }
913         else
914         {
915             if (fun->name)
916                 DPRINTF("%04x:RET  %s.%s() retval=%08x ret=%08x\n",
917                         GetCurrentThreadId(),
918                         ret->dll->name, fun->name, context->Eax, (DWORD)ret->origreturn);
919             else
920                 DPRINTF("%04x:RET  %s.%d() retval=%08x ret=%08x\n",
921                         GetCurrentThreadId(),
922                         ret->dll->name,ret->dll->ordbase+ret->ordinal,
923                         context->Eax, (DWORD)ret->origreturn);
924         }
925         ret->origreturn = NULL; /* mark as empty */
926 }
927
928 /* assembly wrappers that save the context */
929 DEFINE_REGS_ENTRYPOINT( SNOOP_Entry, 0, 0 )
930 DEFINE_REGS_ENTRYPOINT( SNOOP_Return, 0, 0 )
931
932 #else  /* __i386__ */
933
934 FARPROC RELAY_GetProcAddress( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
935                               DWORD exp_size, FARPROC proc, DWORD ordinal, const WCHAR *user )
936 {
937     return proc;
938 }
939
940 FARPROC SNOOP_GetProcAddress( HMODULE hmod, const IMAGE_EXPORT_DIRECTORY *exports, DWORD exp_size,
941                               FARPROC origfun, DWORD ordinal, const WCHAR *user )
942 {
943     return origfun;
944 }
945
946 void RELAY_SetupDLL( HMODULE module )
947 {
948 }
949
950 void SNOOP_SetupDLL( HMODULE hmod )
951 {
952     FIXME("snooping works only on i386 for now.\n");
953 }
954
955 #endif /* __i386__ */