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