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