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__) || defined(__arm__)
  42
  43 WINE_DECLARE_DEBUG_CHANNEL(timestamp);
  44
  45 struct relay_descr  /* descriptor for a module */
  46 {
  47     void               *magic;               /* signature */
  48     void               *relay_call;          /* functions to call from relay thunks */
  49     void               *relay_call_regs;
  50     void               *private;             /* reserved for the relay code private data */
  51     const char         *entry_point_base;    /* base address of entry point thunks */
  52     const unsigned int *entry_point_offsets; /* offsets of entry points thunks */
  53     const unsigned int *arg_types;           /* table of argument types for all entry points */
  54 };
  55
  56 #define RELAY_DESCR_MAGIC  ((void *)0xdeb90001)
  57 #define IS_INTARG(x)       (((ULONG_PTR)(x) >> 16) == 0)
  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 *q = str;
 124
 125         strcpyW( str, buffer );
 126         count = 0;
 127         for (;;)
 128         {
 129             ret[count++] = q;
 130             if (!(q = strchrW( q, ';' ))) break;
 131             *q++ = 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(initial_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_PTR *args, int nb_args, unsigned int typemask )
 306 {
 307     while (nb_args--)
 308     {
 309         if ((typemask & 3) && !IS_INTARG(*args))
 310         {
 311             if (typemask & 2)
 312                 DPRINTF( "%08lx %s", *args, debugstr_w((LPCWSTR)*args) );
 313             else
 314                 DPRINTF( "%08lx %s", *args, debugstr_a((LPCSTR)*args) );
 315         }
 316         else DPRINTF( "%08lx", *args );
 317         if (nb_args) DPRINTF( "," );
 318         args++;
 319         typemask >>= 2;
 320     }
 321 }
 322
 323 extern LONGLONG CDECL call_entry_point( void *func, int nb_args, const INT_PTR *args, int flags );
 324 #ifdef __i386__
 325 __ASM_GLOBAL_FUNC( call_entry_point,
 326                    "pushl %ebp\n\t"
 327                    __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 328                    __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 329                    "movl %esp,%ebp\n\t"
 330                    __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 331                    "pushl %esi\n\t"
 332                   __ASM_CFI(".cfi_rel_offset %esi,-4\n\t")
 333                    "pushl %edi\n\t"
 334                   __ASM_CFI(".cfi_rel_offset %edi,-8\n\t")
 335                    "movl 12(%ebp),%edx\n\t"
 336                    "shll $2,%edx\n\t"
 337                    "jz 1f\n\t"
 338                    "subl %edx,%esp\n\t"
 339                    "andl $~15,%esp\n\t"
 340                    "movl 12(%ebp),%ecx\n\t"
 341                    "movl 16(%ebp),%esi\n\t"
 342                    "movl %esp,%edi\n\t"
 343                    "cld\n\t"
 344                    "rep; movsl\n"
 345                    "testl $2,20(%ebp)\n\t"  /* (flags & 2) -> thiscall */
 346                    "jz 1f\n\t"
 347                    "popl %ecx\n\t"
 348                    "1:\tcall *8(%ebp)\n\t"
 349                    "leal -8(%ebp),%esp\n\t"
 350                    "popl %edi\n\t"
 351                    __ASM_CFI(".cfi_same_value %edi\n\t")
 352                    "popl %esi\n\t"
 353                    __ASM_CFI(".cfi_same_value %esi\n\t")
 354                    "popl %ebp\n\t"
 355                    __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 356                    __ASM_CFI(".cfi_same_value %ebp\n\t")
 357                    "ret" )
 358 #elif defined(__arm__)
 359 __ASM_GLOBAL_FUNC( call_entry_point,
 360                    ".arm\n\t"
 361                    "push {r4, r5, LR}\n\t"
 362                    "mov r4, r0\n\t"
 363                    "mov r5, SP\n\t"
 364                    "lsl r3, r1, #2\n\t"
 365                    "cmp r3, #0\n\t"
 366                    "beq 5f\n\t"
 367                    "sub SP, SP, r3\n\t"
 368                    "tst r1, #1\n\t"
 369                    "subeq SP, SP, #4\n\t"
 370                    "1:\tsub r3, r3, #4\n\t"
 371                    "ldr r0, [r2, r3]\n\t"
 372                    "str r0, [SP, r3]\n\t"
 373                    "cmp r3, #0\n\t"
 374                    "bgt 1b\n\t"
 375                    "cmp r1, #1\n\t"
 376                    "bgt 2f\n\t"
 377                    "pop {r0}\n\t"
 378                    "b 5f\n\t"
 379                    "2:\tcmp r1, #2\n\t"
 380                    "bgt 3f\n\t"
 381                    "pop {r0-r1}\n\t"
 382                    "b 5f\n\t"
 383                    "3:\tcmp r1, #3\n\t"
 384                    "bgt 4f\n\t"
 385                    "pop {r0-r2}\n\t"
 386                    "b 5f\n\t"
 387                    "4:\tpop {r0-r3}\n\t"
 388                    "5:\tblx r4\n\t"
 389                    "mov SP, r5\n\t"
 390                    "pop {r4, r5, PC}" )
 391 #else
 392 __ASM_GLOBAL_FUNC( call_entry_point,
 393                    "pushq %rbp\n\t"
 394                    __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
 395                    __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
 396                    "movq %rsp,%rbp\n\t"
 397                    __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
 398                    "pushq %rsi\n\t"
 399                    __ASM_CFI(".cfi_rel_offset %rsi,-8\n\t")
 400                    "pushq %rdi\n\t"
 401                    __ASM_CFI(".cfi_rel_offset %rdi,-16\n\t")
 402                    "movq %rcx,%rax\n\t"
 403                    "movq $4,%rcx\n\t"
 404                    "cmp %rcx,%rdx\n\t"
 405                    "cmovgq %rdx,%rcx\n\t"
 406                    "leaq 0(,%rcx,8),%rdx\n\t"
 407                    "subq %rdx,%rsp\n\t"
 408                    "andq $~15,%rsp\n\t"
 409                    "movq %rsp,%rdi\n\t"
 410                    "movq %r8,%rsi\n\t"
 411                    "rep; movsq\n\t"
 412                    "movq 0(%rsp),%rcx\n\t"
 413                    "movq 8(%rsp),%rdx\n\t"
 414                    "movq 16(%rsp),%r8\n\t"
 415                    "movq 24(%rsp),%r9\n\t"
 416                    "movq %rcx,%xmm0\n\t"
 417                    "movq %rdx,%xmm1\n\t"
 418                    "movq %r8,%xmm2\n\t"
 419                    "movq %r9,%xmm3\n\t"
 420                    "callq *%rax\n\t"
 421                    "leaq -16(%rbp),%rsp\n\t"
 422                    "popq %rdi\n\t"
 423                    __ASM_CFI(".cfi_same_value %rdi\n\t")
 424                    "popq %rsi\n\t"
 425                    __ASM_CFI(".cfi_same_value %rsi\n\t")
 426                    __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
 427                    "popq %rbp\n\t"
 428                    __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
 429                    __ASM_CFI(".cfi_same_value %rbp\n\t")
 430                    "ret")
 431 #endif
 432
 433
 434 static void print_timestamp(void)
 435 {
 436     ULONG ticks = NtGetTickCount();
 437     DPRINTF( "%3u.%03u:", ticks / 1000, ticks % 1000 );
 438 }
 439
 440
 441 /***********************************************************************
 442  *           relay_call
 443  *
 444  * stack points to the return address, i.e. the first argument is stack[1].
 445  */
 446 static LONGLONG WINAPI relay_call( struct relay_descr *descr, unsigned int idx, const INT_PTR *stack )
 447 {
 448     LONGLONG ret;
 449     WORD ordinal = LOWORD(idx);
 450     BYTE nb_args = LOBYTE(HIWORD(idx));
 451     BYTE flags   = HIBYTE(HIWORD(idx));
 452     struct relay_private_data *data = descr->private;
 453     struct relay_entry_point *entry_point = data->entry_points + ordinal;
 454
 455     if (!TRACE_ON(relay))
 456         ret = call_entry_point( entry_point->orig_func, nb_args, stack + 1, flags );
 457     else
 458     {
 459         if (TRACE_ON(timestamp))
 460             print_timestamp();
 461         if (entry_point->name)
 462             DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
 463         else
 464             DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
 465         RELAY_PrintArgs( stack + 1, nb_args, descr->arg_types[ordinal] );
 466         DPRINTF( ") ret=%08lx\n", stack[0] );
 467
 468         ret = call_entry_point( entry_point->orig_func, nb_args, stack + 1, flags );
 469
 470         if (TRACE_ON(timestamp))
 471             print_timestamp();
 472         if (entry_point->name)
 473             DPRINTF( "%04x:Ret  %s.%s()", GetCurrentThreadId(), data->dllname, entry_point->name );
 474         else
 475             DPRINTF( "%04x:Ret  %s.%u()", GetCurrentThreadId(), data->dllname, data->base + ordinal );
 476
 477         if (flags & 1)  /* 64-bit return value */
 478             DPRINTF( " retval=%08x%08x ret=%08lx\n",
 479                      (UINT)(ret >> 32), (UINT)ret, stack[0] );
 480         else
 481             DPRINTF( " retval=%08lx ret=%08lx\n", (UINT_PTR)ret, stack[0] );
 482     }
 483     return ret;
 484 }
 485
 486
 487 /***********************************************************************
 488  *           relay_call_regs
 489  */
 490 #ifdef __i386__
 491 void WINAPI __regs_relay_call_regs( struct relay_descr *descr, unsigned int idx,
 492                                     unsigned int orig_eax, unsigned int ret_addr,
 493                                     CONTEXT *context )
 494 {
 495     WORD ordinal = LOWORD(idx);
 496     BYTE nb_args = LOBYTE(HIWORD(idx));
 497     struct relay_private_data *data = descr->private;
 498     struct relay_entry_point *entry_point = data->entry_points + ordinal;
 499     BYTE *orig_func = entry_point->orig_func;
 500     INT_PTR *args = (INT_PTR *)context->Esp;
 501     INT_PTR args_copy[32];
 502
 503     /* restore the context to what it was before the relay thunk */
 504     context->Eax = orig_eax;
 505     context->Eip = ret_addr;
 506     context->Esp += nb_args * sizeof(int);
 507
 508     if (TRACE_ON(relay))
 509     {
 510         if (entry_point->name)
 511             DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
 512         else
 513             DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
 514         RELAY_PrintArgs( args, nb_args, descr->arg_types[ordinal] );
 515         DPRINTF( ") ret=%08x\n", ret_addr );
 516
 517         DPRINTF( "%04x:  eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
 518                  "ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
 519                  GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
 520                  context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
 521                  context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
 522
 523         assert( orig_func[0] == 0x68 /* pushl func */ );
 524         assert( orig_func[5] == 0x6a /* pushl args */ );
 525         assert( orig_func[7] == 0xe8 /* call */ );
 526     }
 527
 528     /* now call the real function */
 529
 530     memcpy( args_copy, args, nb_args * sizeof(args[0]) );
 531     args_copy[nb_args++] = (INT_PTR)context;  /* append context argument */
 532
 533     call_entry_point( orig_func + 12 + *(int *)(orig_func + 1), nb_args, args_copy, 0 );
 534
 535
 536     if (TRACE_ON(relay))
 537     {
 538         if (entry_point->name)
 539             DPRINTF( "%04x:Ret  %s.%s() retval=%08x ret=%08x\n",
 540                      GetCurrentThreadId(), data->dllname, entry_point->name,
 541                      context->Eax, context->Eip );
 542         else
 543             DPRINTF( "%04x:Ret  %s.%u() retval=%08x ret=%08x\n",
 544                      GetCurrentThreadId(), data->dllname, data->base + ordinal,
 545                      context->Eax, context->Eip );
 546         DPRINTF( "%04x:  eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
 547                  "ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
 548                  GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
 549                  context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
 550                  context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
 551     }
 552 }
 553 extern void WINAPI relay_call_regs(void);
 554 DEFINE_REGS_ENTRYPOINT( relay_call_regs, 4 )
 555
 556 #else  /* __i386__ */
 557
 558 void WINAPI relay_call_regs( struct relay_descr *descr, INT_PTR idx, INT_PTR *stack )
 559 {
 560     assert(0);  /* should never be called */
 561 }
 562
 563 #endif  /* __i386__ */
 564
 565
 566 /***********************************************************************
 567  *           RELAY_GetProcAddress
 568  *
 569  * Return the proc address to use for a given function.
 570  */
 571 FARPROC RELAY_GetProcAddress( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
 572                               DWORD exp_size, FARPROC proc, DWORD ordinal, const WCHAR *user )
 573 {
 574     struct relay_private_data *data;
 575     const struct relay_descr *descr = (const struct relay_descr *)((const char *)exports + exp_size);
 576
 577     if (descr->magic != RELAY_DESCR_MAGIC || !(data = descr->private)) return proc;  /* no relay data */
 578     if (!data->entry_points[ordinal].orig_func) return proc;  /* not a relayed function */
 579     if (check_from_module( debug_from_relay_includelist, debug_from_relay_excludelist, user ))
 580         return proc;  /* we want to relay it */
 581     return data->entry_points[ordinal].orig_func;
 582 }
 583
 584
 585 /***********************************************************************
 586  *           RELAY_SetupDLL
 587  *
 588  * Setup relay debugging for a built-in dll.
 589  */
 590 void RELAY_SetupDLL( HMODULE module )
 591 {
 592     IMAGE_EXPORT_DIRECTORY *exports;
 593     DWORD *funcs;
 594     unsigned int i, len;
 595     DWORD size, entry_point_rva;
 596     struct relay_descr *descr;
 597     struct relay_private_data *data;
 598     const WORD *ordptr;
 599
 600     if (!init_done) init_debug_lists();
 601
 602     exports = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size );
 603     if (!exports) return;
 604
 605     descr = (struct relay_descr *)((char *)exports + size);
 606     if (descr->magic != RELAY_DESCR_MAGIC) return;
 607
 608     if (!(data = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data) +
 609                                   (exports->NumberOfFunctions-1) * sizeof(data->entry_points) )))
 610         return;
 611
 612     descr->relay_call = relay_call;
 613     descr->relay_call_regs = relay_call_regs;
 614     descr->private = data;
 615
 616     data->module = module;
 617     data->base   = exports->Base;
 618     len = strlen( (char *)module + exports->Name );
 619     if (len > 4 && !strcasecmp( (char *)module + exports->Name + len - 4, ".dll" )) len -= 4;
 620     len = min( len, sizeof(data->dllname) - 1 );
 621     memcpy( data->dllname, (char *)module + exports->Name, len );
 622     data->dllname[len] = 0;
 623
 624     /* fetch name pointer for all entry points and store them in the private structure */
 625
 626     ordptr = (const WORD *)((char *)module + exports->AddressOfNameOrdinals);
 627     for (i = 0; i < exports->NumberOfNames; i++, ordptr++)
 628     {
 629         DWORD name_rva = ((DWORD*)((char *)module + exports->AddressOfNames))[i];
 630         data->entry_points[*ordptr].name = (const char *)module + name_rva;
 631     }
 632
 633     /* patch the functions in the export table to point to the relay thunks */
 634
 635     funcs = (DWORD *)((char *)module + exports->AddressOfFunctions);
 636     entry_point_rva = descr->entry_point_base - (const char *)module;
 637     for (i = 0; i < exports->NumberOfFunctions; i++, funcs++)
 638     {
 639         if (!descr->entry_point_offsets[i]) continue;   /* not a normal function */
 640         if (!check_relay_include( data->dllname, i + exports->Base, data->entry_points[i].name ))
 641             continue;  /* don't include this entry point */
 642
 643         data->entry_points[i].orig_func = (char *)module + *funcs;
 644         *funcs = entry_point_rva + descr->entry_point_offsets[i];
 645     }
 646 }
 647
 648 #else  /* __i386__ || __x86_64__ */
 649
 650 FARPROC RELAY_GetProcAddress( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
 651                               DWORD exp_size, FARPROC proc, DWORD ordinal, const WCHAR *user )
 652 {
 653     return proc;
 654 }
 655
 656 void RELAY_SetupDLL( HMODULE module )
 657 {
 658 }
 659
 660 #endif  /* __i386__ || __x86_64__ */
 661
 662
 663 /***********************************************************************/
 664 /* snoop support */
 665 /***********************************************************************/
 666
 667 #ifdef __i386__
 668
 669 WINE_DECLARE_DEBUG_CHANNEL(seh);
 670 WINE_DECLARE_DEBUG_CHANNEL(snoop);
 671
 672 #include "pshpack1.h"
 673
 674 typedef struct
 675 {
 676         /* code part */
 677         BYTE            lcall;          /* 0xe8 call snoopentry (relative) */
 678         /* NOTE: If you move snoopentry OR nrofargs fix the relative offset
 679          * calculation!
 680          */
 681         DWORD           snoopentry;     /* SNOOP_Entry relative */
 682         /* unreached */
 683         int             nrofargs;
 684         FARPROC origfun;
 685         const char *name;
 686 } SNOOP_FUN;
 687
 688 typedef struct tagSNOOP_DLL {
 689         HMODULE hmod;
 690         SNOOP_FUN       *funs;
 691         DWORD           ordbase;
 692         DWORD           nrofordinals;
 693         struct tagSNOOP_DLL     *next;
 694         char name[1];
 695 } SNOOP_DLL;
 696
 697 typedef struct
 698 {
 699         /* code part */
 700         BYTE            lcall;          /* 0xe8 call snoopret relative*/
 701         /* NOTE: If you move snoopret OR origreturn fix the relative offset
 702          * calculation!
 703          */
 704         DWORD           snoopret;       /* SNOOP_Ret relative */
 705         /* unreached */
 706         FARPROC origreturn;
 707         SNOOP_DLL       *dll;
 708         DWORD           ordinal;
 709         DWORD           origESP;
 710         DWORD           *args;          /* saved args across a stdcall */
 711 } SNOOP_RETURNENTRY;
 712
 713 typedef struct tagSNOOP_RETURNENTRIES {
 714         SNOOP_RETURNENTRY entry[4092/sizeof(SNOOP_RETURNENTRY)];
 715         struct tagSNOOP_RETURNENTRIES   *next;
 716 } SNOOP_RETURNENTRIES;
 717
 718 #include "poppack.h"
 719
 720 extern void WINAPI SNOOP_Entry(void);
 721 extern void WINAPI SNOOP_Return(void);
 722
 723 static SNOOP_DLL *firstdll;
 724 static SNOOP_RETURNENTRIES *firstrets;
 725
 726
 727 /***********************************************************************
 728  *          SNOOP_ShowDebugmsgSnoop
 729  *
 730  * Simple function to decide if a particular debugging message is
 731  * wanted.
 732  */
 733 static BOOL SNOOP_ShowDebugmsgSnoop(const char *module, int ordinal, const char *func)
 734 {
 735     if (debug_snoop_excludelist && check_list( module, ordinal, func, debug_snoop_excludelist ))
 736         return FALSE;
 737     if (debug_snoop_includelist && !check_list( module, ordinal, func, debug_snoop_includelist ))
 738         return FALSE;
 739     return TRUE;
 740 }
 741
 742
 743 /***********************************************************************
 744  *           SNOOP_SetupDLL
 745  *
 746  * Setup snoop debugging for a native dll.
 747  */
 748 void SNOOP_SetupDLL(HMODULE hmod)
 749 {
 750     SNOOP_DLL **dll = &firstdll;
 751     char *p, *name;
 752     void *addr;
 753     SIZE_T size;
 754     ULONG size32;
 755     IMAGE_EXPORT_DIRECTORY *exports;
 756
 757     if (!init_done) init_debug_lists();
 758
 759     exports = RtlImageDirectoryEntryToData( hmod, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size32 );
 760     if (!exports || !exports->NumberOfFunctions) return;
 761     name = (char *)hmod + exports->Name;
 762     size = size32;
 763
 764     TRACE_(snoop)("hmod=%p, name=%s\n", hmod, name);
 765
 766     while (*dll) {
 767         if ((*dll)->hmod == hmod)
 768         {
 769             /* another dll, loaded at the same address */
 770             addr = (*dll)->funs;
 771             size = (*dll)->nrofordinals * sizeof(SNOOP_FUN);
 772             NtFreeVirtualMemory(NtCurrentProcess(), &addr, &size, MEM_RELEASE);
 773             break;
 774         }
 775         dll = &((*dll)->next);
 776     }
 777     if (*dll)
 778         *dll = RtlReAllocateHeap(GetProcessHeap(),
 779                              HEAP_ZERO_MEMORY, *dll,
 780                              sizeof(SNOOP_DLL) + strlen(name));
 781     else
 782         *dll = RtlAllocateHeap(GetProcessHeap(),
 783                              HEAP_ZERO_MEMORY,
 784                              sizeof(SNOOP_DLL) + strlen(name));
 785     (*dll)->hmod        = hmod;
 786     (*dll)->ordbase = exports->Base;
 787     (*dll)->nrofordinals = exports->NumberOfFunctions;
 788     strcpy( (*dll)->name, name );
 789     p = (*dll)->name + strlen((*dll)->name) - 4;
 790     if (p > (*dll)->name && !strcasecmp( p, ".dll" )) *p = 0;
 791
 792     size = exports->NumberOfFunctions * sizeof(SNOOP_FUN);
 793     addr = NULL;
 794     NtAllocateVirtualMemory(NtCurrentProcess(), &addr, 0, &size,
 795                             MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
 796     if (!addr) {
 797         RtlFreeHeap(GetProcessHeap(),0,*dll);
 798         FIXME("out of memory\n");
 799         return;
 800     }
 801     (*dll)->funs = addr;
 802     memset((*dll)->funs,0,size);
 803 }
 804
 805
 806 /***********************************************************************
 807  *           SNOOP_GetProcAddress
 808  *
 809  * Return the proc address to use for a given function.
 810  */
 811 FARPROC SNOOP_GetProcAddress( HMODULE hmod, const IMAGE_EXPORT_DIRECTORY *exports,
 812                               DWORD exp_size, FARPROC origfun, DWORD ordinal,
 813                               const WCHAR *user)
 814 {
 815     unsigned int i;
 816     const char *ename;
 817     const WORD *ordinals;
 818     const DWORD *names;
 819     SNOOP_DLL *dll = firstdll;
 820     SNOOP_FUN *fun;
 821     const IMAGE_SECTION_HEADER *sec;
 822
 823     if (!TRACE_ON(snoop)) return origfun;
 824     if (!check_from_module( debug_from_snoop_includelist, debug_from_snoop_excludelist, user ))
 825         return origfun; /* the calling module was explicitly excluded */
 826
 827     if (!*(LPBYTE)origfun) /* 0x00 is an impossible opcode, possible dataref. */
 828         return origfun;
 829
 830     sec = RtlImageRvaToSection( RtlImageNtHeader(hmod), hmod, (char *)origfun - (char *)hmod );
 831
 832     if (!sec || !(sec->Characteristics & IMAGE_SCN_CNT_CODE))
 833         return origfun;  /* most likely a data reference */
 834
 835     while (dll) {
 836         if (hmod == dll->hmod)
 837             break;
 838         dll = dll->next;
 839     }
 840     if (!dll)   /* probably internal */
 841         return origfun;
 842
 843     /* try to find a name for it */
 844     ename = NULL;
 845     names = (const DWORD *)((const char *)hmod + exports->AddressOfNames);
 846     ordinals = (const WORD *)((const char *)hmod + exports->AddressOfNameOrdinals);
 847     if (names) for (i = 0; i < exports->NumberOfNames; i++)
 848     {
 849         if (ordinals[i] == ordinal)
 850         {
 851             ename = (const char *)hmod + names[i];
 852             break;
 853         }
 854     }
 855     if (!SNOOP_ShowDebugmsgSnoop(dll->name,ordinal,ename))
 856         return origfun;
 857     assert(ordinal < dll->nrofordinals);
 858     fun = dll->funs + ordinal;
 859     if (!fun->name)
 860     {
 861         fun->name       = ename;
 862         fun->lcall      = 0xe8;
 863         /* NOTE: origreturn struct member MUST come directly after snoopentry */
 864         fun->snoopentry = (char*)SNOOP_Entry-((char*)(&fun->nrofargs));
 865         fun->origfun    = origfun;
 866         fun->nrofargs   = -1;
 867     }
 868     return (FARPROC)&(fun->lcall);
 869 }
 870
 871 static void SNOOP_PrintArg(DWORD x)
 872 {
 873     int i,nostring;
 874
 875     DPRINTF("%08x",x);
 876     if (IS_INTARG(x) || TRACE_ON(seh)) return; /* trivial reject to avoid faults */
 877     __TRY
 878     {
 879         LPBYTE s=(LPBYTE)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]>=0x80) {nostring=1;break;}
 885             i++;
 886         }
 887         if (!nostring && i > 5)
 888             DPRINTF(" %s",debugstr_an((LPSTR)x,i));
 889         else  /* try unicode */
 890         {
 891             LPWSTR s=(LPWSTR)x;
 892             i=0;nostring=0;
 893             while (i<80) {
 894                 if (s[i]==0) break;
 895                 if (s[i]<0x20) {nostring=1;break;}
 896                 if (s[i]>0x100) {nostring=1;break;}
 897                 i++;
 898             }
 899             if (!nostring && i > 5) DPRINTF(" %s",debugstr_wn((LPWSTR)x,i));
 900         }
 901     }
 902     __EXCEPT_PAGE_FAULT
 903     {
 904     }
 905     __ENDTRY
 906 }
 907
 908 #define CALLER1REF (*(DWORD*)context->Esp)
 909
 910 void WINAPI __regs_SNOOP_Entry( CONTEXT *context )
 911 {
 912         DWORD           ordinal=0,entry = context->Eip - 5;
 913         SNOOP_DLL       *dll = firstdll;
 914         SNOOP_FUN       *fun = NULL;
 915         SNOOP_RETURNENTRIES     **rets = &firstrets;
 916         SNOOP_RETURNENTRY       *ret;
 917         int             i=0, max;
 918
 919         while (dll) {
 920                 if (    ((char*)entry>=(char*)dll->funs)        &&
 921                         ((char*)entry<=(char*)(dll->funs+dll->nrofordinals))
 922                 ) {
 923                         fun = (SNOOP_FUN*)entry;
 924                         ordinal = fun-dll->funs;
 925                         break;
 926                 }
 927                 dll=dll->next;
 928         }
 929         if (!dll) {
 930                 FIXME("entrypoint 0x%08x not found\n",entry);
 931                 return; /* oops */
 932         }
 933         /* guess cdecl ... */
 934         if (fun->nrofargs<0) {
 935                 /* Typical cdecl return frame is:
 936                  *     add esp, xxxxxxxx
 937                  * which has (for xxxxxxxx up to 255 the opcode "83 C4 xx".
 938                  * (after that 81 C2 xx xx xx xx)
 939                  */
 940                 LPBYTE  reteip = (LPBYTE)CALLER1REF;
 941
 942                 if (reteip) {
 943                         if ((reteip[0]==0x83)&&(reteip[1]==0xc4))
 944                                 fun->nrofargs=reteip[2]/4;
 945                 }
 946         }
 947
 948
 949         while (*rets) {
 950                 for (i=0;i<sizeof((*rets)->entry)/sizeof((*rets)->entry[0]);i++)
 951                         if (!(*rets)->entry[i].origreturn)
 952                                 break;
 953                 if (i!=sizeof((*rets)->entry)/sizeof((*rets)->entry[0]))
 954                         break;
 955                 rets = &((*rets)->next);
 956         }
 957         if (!*rets) {
 958                 SIZE_T size = 4096;
 959                 VOID* addr = NULL;
 960
 961                 NtAllocateVirtualMemory(NtCurrentProcess(), &addr, 0, &size,
 962                                         MEM_COMMIT | MEM_RESERVE,
 963                                         PAGE_EXECUTE_READWRITE);
 964                 if (!addr) return;
 965                 *rets = addr;
 966                 memset(*rets,0,4096);
 967                 i = 0;  /* entry 0 is free */
 968         }
 969         ret = &((*rets)->entry[i]);
 970         ret->lcall      = 0xe8;
 971         /* NOTE: origreturn struct member MUST come directly after snoopret */
 972         ret->snoopret   = ((char*)SNOOP_Return)-(char*)(&ret->origreturn);
 973         ret->origreturn = (FARPROC)CALLER1REF;
 974         CALLER1REF      = (DWORD)&ret->lcall;
 975         ret->dll        = dll;
 976         ret->args       = NULL;
 977         ret->ordinal    = ordinal;
 978         ret->origESP    = context->Esp;
 979
 980         context->Eip = (DWORD)fun->origfun;
 981
 982         if (TRACE_ON(timestamp))
 983                 print_timestamp();
 984         if (fun->name) DPRINTF("%04x:CALL %s.%s(",GetCurrentThreadId(),dll->name,fun->name);
 985         else DPRINTF("%04x:CALL %s.%d(",GetCurrentThreadId(),dll->name,dll->ordbase+ordinal);
 986         if (fun->nrofargs>0) {
 987                 max = fun->nrofargs; if (max>16) max=16;
 988                 for (i=0;i<max;i++)
 989                 {
 990                     SNOOP_PrintArg(*(DWORD*)(context->Esp + 4 + sizeof(DWORD)*i));
 991                     if (i<fun->nrofargs-1) DPRINTF(",");
 992                 }
 993                 if (max!=fun->nrofargs)
 994                         DPRINTF(" ...");
 995         } else if (fun->nrofargs<0) {
 996                 DPRINTF("<unknown, check return>");
 997                 ret->args = RtlAllocateHeap(GetProcessHeap(),
 998                                             0,16*sizeof(DWORD));
 999                 memcpy(ret->args,(LPBYTE)(context->Esp + 4),sizeof(DWORD)*16);
1000         }
1001         DPRINTF(") ret=%08x\n",(DWORD)ret->origreturn);
1002 }
1003
1004
1005 void WINAPI __regs_SNOOP_Return( CONTEXT *context )
1006 {
1007         SNOOP_RETURNENTRY       *ret = (SNOOP_RETURNENTRY*)(context->Eip - 5);
1008         SNOOP_FUN *fun = &ret->dll->funs[ret->ordinal];
1009
1010         /* We haven't found out the nrofargs yet. If we called a cdecl
1011          * function it is too late anyway and we can just set '0' (which
1012          * will be the difference between orig and current ESP
1013          * If stdcall -> everything ok.
1014          */
1015         if (ret->dll->funs[ret->ordinal].nrofargs<0)
1016                 ret->dll->funs[ret->ordinal].nrofargs=(context->Esp - ret->origESP-4)/4;
1017         context->Eip = (DWORD)ret->origreturn;
1018         if (TRACE_ON(timestamp))
1019                 print_timestamp();
1020         if (ret->args) {
1021                 int     i,max;
1022
1023                 if (fun->name)
1024                     DPRINTF("%04x:RET  %s.%s(", GetCurrentThreadId(), ret->dll->name, fun->name);
1025                 else
1026                     DPRINTF("%04x:RET  %s.%d(", GetCurrentThreadId(),
1027                             ret->dll->name,ret->dll->ordbase+ret->ordinal);
1028
1029                 max = fun->nrofargs;
1030                 if (max>16) max=16;
1031
1032                 for (i=0;i<max;i++)
1033                 {
1034                     SNOOP_PrintArg(ret->args[i]);
1035                     if (i<max-1) DPRINTF(",");
1036                 }
1037                 DPRINTF(") retval=%08x ret=%08x\n",
1038                         context->Eax,(DWORD)ret->origreturn );
1039                 RtlFreeHeap(GetProcessHeap(),0,ret->args);
1040                 ret->args = NULL;
1041         }
1042         else
1043         {
1044             if (fun->name)
1045                 DPRINTF("%04x:RET  %s.%s() retval=%08x ret=%08x\n",
1046                         GetCurrentThreadId(),
1047                         ret->dll->name, fun->name, context->Eax, (DWORD)ret->origreturn);
1048             else
1049                 DPRINTF("%04x:RET  %s.%d() retval=%08x ret=%08x\n",
1050                         GetCurrentThreadId(),
1051                         ret->dll->name,ret->dll->ordbase+ret->ordinal,
1052                         context->Eax, (DWORD)ret->origreturn);
1053         }
1054         ret->origreturn = NULL; /* mark as empty */
1055 }
1056
1057 /* assembly wrappers that save the context */
1058 DEFINE_REGS_ENTRYPOINT( SNOOP_Entry, 0 )
1059 DEFINE_REGS_ENTRYPOINT( SNOOP_Return, 0 )
1060
1061 #else  /* __i386__ */
1062
1063 FARPROC SNOOP_GetProcAddress( HMODULE hmod, const IMAGE_EXPORT_DIRECTORY *exports, DWORD exp_size,
1064                               FARPROC origfun, DWORD ordinal, const WCHAR *user )
1065 {
1066     return origfun;
1067 }
1068
1069 void SNOOP_SetupDLL( HMODULE hmod )
1070 {
1071     FIXME("snooping works only on i386 for now.\n");
1072 }
1073
1074 #endif /* __i386__ */