strmbase: Add support for rendering algorithms to quality control.
[wine] / dlls / krnl386.exe16 / relay.c
1 /*
2  * Copyright 1993 Robert J. Amstadt
3  * Copyright 1995 Alexandre Julliard
4  * Copyright 2002 Jukka Heinonen
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wine/winbase16.h"
33 #include "winternl.h"
34 #include "kernel16_private.h"
35 #include "dosexe.h"
36 #include "wine/unicode.h"
37 #include "wine/library.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(relay);
41
42 /*
43  * Magic DWORD used to check stack integrity.
44  */
45 #define RELAY_MAGIC 0xabcdef00
46
47 /*
48  * Memory block for temporary 16-bit stacks used with relay calls.
49  */
50 typedef struct {
51     DWORD inuse;          /* non-zero if stack block is in use */
52     DWORD eip;            /* saved ip */
53     DWORD seg_cs;         /* saved cs */
54     DWORD esp;            /* saved sp */
55     DWORD seg_ss;         /* saved ss */
56     DWORD stack_bottom;   /* guard dword */
57     BYTE  stack[256-7*4]; /* 16-bit stack */
58     DWORD stack_top;      /* guard dword */
59 } RELAY_Stack16;
60
61
62 static const WCHAR **debug_relay_excludelist;
63 static const WCHAR **debug_relay_includelist;
64 static const WCHAR **debug_snoop_excludelist;
65 static const WCHAR **debug_snoop_includelist;
66
67 /* compare an ASCII and a Unicode string without depending on the current codepage */
68 static inline int strcmpiAW( const char *strA, const WCHAR *strW )
69 {
70     while (*strA && (toupperW((unsigned char)*strA) == toupperW(*strW))) { strA++; strW++; }
71     return toupperW((unsigned char)*strA) - toupperW(*strW);
72 }
73
74 /* compare an ASCII and a Unicode string without depending on the current codepage */
75 static inline int strncmpiAW( const char *strA, const WCHAR *strW, int n )
76 {
77     int ret = 0;
78     for ( ; n > 0; n--, strA++, strW++)
79         if ((ret = toupperW((unsigned char)*strA) - toupperW(*strW)) || !*strA) break;
80     return ret;
81 }
82
83 /***********************************************************************
84  *           build_list
85  *
86  * Build a function list from a ';'-separated string.
87  */
88 static const WCHAR **build_list( const WCHAR *buffer )
89 {
90     int count = 1;
91     const WCHAR *p = buffer;
92     const WCHAR **ret;
93
94     while ((p = strchrW( p, ';' )))
95     {
96         count++;
97         p++;
98     }
99     /* allocate count+1 pointers, plus the space for a copy of the string */
100     if ((ret = RtlAllocateHeap( GetProcessHeap(), 0,
101                                 (count+1) * sizeof(WCHAR*) + (strlenW(buffer)+1) * sizeof(WCHAR) )))
102     {
103         WCHAR *str = (WCHAR *)(ret + count + 1);
104         WCHAR *p = str;
105
106         strcpyW( str, buffer );
107         count = 0;
108         for (;;)
109         {
110             ret[count++] = p;
111             if (!(p = strchrW( p, ';' ))) break;
112             *p++ = 0;
113         }
114         ret[count++] = NULL;
115     }
116     return ret;
117 }
118
119
120 /***********************************************************************
121  *           RELAY16_InitDebugLists
122  *
123  * Build the relay include/exclude function lists.
124  */
125 void RELAY16_InitDebugLists(void)
126 {
127     OBJECT_ATTRIBUTES attr;
128     UNICODE_STRING name;
129     char buffer[1024];
130     HANDLE root, hkey;
131     DWORD count;
132     WCHAR *str;
133     static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\',
134                                     'W','i','n','e','\\',
135                                     'D','e','b','u','g',0};
136     static const WCHAR RelayIncludeW[] = {'R','e','l','a','y','I','n','c','l','u','d','e',0};
137     static const WCHAR RelayExcludeW[] = {'R','e','l','a','y','E','x','c','l','u','d','e',0};
138     static const WCHAR SnoopIncludeW[] = {'S','n','o','o','p','I','n','c','l','u','d','e',0};
139     static const WCHAR SnoopExcludeW[] = {'S','n','o','o','p','E','x','c','l','u','d','e',0};
140
141     RtlOpenCurrentUser( KEY_READ, &root );
142     attr.Length = sizeof(attr);
143     attr.RootDirectory = root;
144     attr.ObjectName = &name;
145     attr.Attributes = 0;
146     attr.SecurityDescriptor = NULL;
147     attr.SecurityQualityOfService = NULL;
148     RtlInitUnicodeString( &name, configW );
149
150     /* @@ Wine registry key: HKCU\Software\Wine\Debug */
151     if (NtOpenKey( &hkey, KEY_READ, &attr )) hkey = 0;
152     NtClose( root );
153     if (!hkey) return;
154
155     str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)buffer)->Data;
156     RtlInitUnicodeString( &name, RelayIncludeW );
157     if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
158     {
159         debug_relay_includelist = build_list( str );
160     }
161
162     RtlInitUnicodeString( &name, RelayExcludeW );
163     if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
164     {
165         debug_relay_excludelist = build_list( str );
166     }
167
168     RtlInitUnicodeString( &name, SnoopIncludeW );
169     if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
170     {
171         debug_snoop_includelist = build_list( str );
172     }
173
174     RtlInitUnicodeString( &name, SnoopExcludeW );
175     if (!NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count ))
176     {
177         debug_snoop_excludelist = build_list( str );
178     }
179     NtClose( hkey );
180 }
181
182
183 /***********************************************************************
184  *           check_list
185  *
186  * Check if a given module and function is in the list.
187  */
188 static BOOL check_list( const char *module, int ordinal, const char *func, const WCHAR **list )
189 {
190     char ord_str[10];
191
192     sprintf( ord_str, "%d", ordinal );
193     for(; *list; list++)
194     {
195         const WCHAR *p = strrchrW( *list, '.' );
196         if (p && p > *list)  /* check module and function */
197         {
198             int len = p - *list;
199             if (strncmpiAW( module, *list, len-1 ) || module[len]) continue;
200             if (p[1] == '*' && !p[2]) return TRUE;
201             if (!strcmpiAW( ord_str, p + 1 )) return TRUE;
202             if (func && !strcmpiAW( func, p + 1 )) return TRUE;
203         }
204         else  /* function only */
205         {
206             if (func && !strcmpiAW( func, *list )) return TRUE;
207         }
208     }
209     return FALSE;
210 }
211
212
213 /***********************************************************************
214  *           RELAY_ShowDebugmsgRelay
215  *
216  * Simple function to decide if a particular debugging message is
217  * wanted.
218  */
219 static BOOL RELAY_ShowDebugmsgRelay(const char *module, int ordinal, const char *func)
220 {
221     if (debug_relay_excludelist && check_list( module, ordinal, func, debug_relay_excludelist ))
222         return FALSE;
223     if (debug_relay_includelist && !check_list( module, ordinal, func, debug_relay_includelist ))
224         return FALSE;
225     return TRUE;
226 }
227
228
229 /***********************************************************************
230  *          SNOOP16_ShowDebugmsgSnoop
231  *
232  * Simple function to decide if a particular debugging message is
233  * wanted.
234  */
235 int SNOOP16_ShowDebugmsgSnoop(const char *module, int ordinal, const char *func)
236 {
237     if (debug_snoop_excludelist && check_list( module, ordinal, func, debug_snoop_excludelist ))
238         return FALSE;
239     if (debug_snoop_includelist && !check_list( module, ordinal, func, debug_snoop_includelist ))
240         return FALSE;
241     return TRUE;
242 }
243
244
245 /***********************************************************************
246  *           get_entry_point
247  *
248  * Return the ordinal, name, and type info corresponding to a CS:IP address.
249  */
250 static const CALLFROM16 *get_entry_point( STACK16FRAME *frame, LPSTR module, LPSTR func, WORD *pOrd )
251 {
252     WORD i, max_offset;
253     register BYTE *p;
254     NE_MODULE *pModule;
255     ET_BUNDLE *bundle;
256     ET_ENTRY *entry;
257
258     *pOrd = 0;
259     if (!(pModule = NE_GetPtr( FarGetOwner16( GlobalHandle16( frame->module_cs ) ))))
260         return NULL;
261
262     max_offset = 0;
263     bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule->ne_enttab);
264     do
265     {
266         entry = (ET_ENTRY *)((BYTE *)bundle+6);
267         for (i = bundle->first + 1; i <= bundle->last; i++)
268         {
269             if ((entry->offs < frame->entry_ip)
270             && (entry->segnum == 1) /* code segment ? */
271             && (entry->offs >= max_offset))
272             {
273                 max_offset = entry->offs;
274                 *pOrd = i;
275             }
276             entry++;
277         }
278     } while ( (bundle->next)
279            && (bundle = (ET_BUNDLE *)((BYTE *)pModule+bundle->next)));
280
281     /* Search for the name in the resident names table */
282     /* (built-in modules have no non-resident table)   */
283
284     p = (BYTE *)pModule + pModule->ne_restab;
285     memcpy( module, p + 1, *p );
286     module[*p] = 0;
287
288     while (*p)
289     {
290         p += *p + 1 + sizeof(WORD);
291         if (*(WORD *)(p + *p + 1) == *pOrd) break;
292     }
293     memcpy( func, p + 1, *p );
294     func[*p] = 0;
295
296     /* Retrieve entry point call structure */
297     p = MapSL( MAKESEGPTR( frame->module_cs, frame->callfrom_ip ) );
298     /* p now points to lret, get the start of CALLFROM16 structure */
299     return (CALLFROM16 *)(p - FIELD_OFFSET( CALLFROM16, ret ));
300 }
301
302
303 extern int call_entry_point( void *func, int nb_args, const int *args );
304 __ASM_GLOBAL_FUNC( call_entry_point,
305                    "pushl %ebp\n\t"
306                    __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
307                    __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
308                    "movl %esp,%ebp\n\t"
309                    __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
310                    "pushl %esi\n\t"
311                    __ASM_CFI(".cfi_rel_offset %esi,-4\n\t")
312                    "pushl %edi\n\t"
313                    __ASM_CFI(".cfi_rel_offset %edi,-8\n\t")
314                    "movl 12(%ebp),%edx\n\t"
315                    "shll $2,%edx\n\t"
316                    "jz 1f\n\t"
317                    "subl %edx,%esp\n\t"
318                    "andl $~15,%esp\n\t"
319                    "movl 12(%ebp),%ecx\n\t"
320                    "movl 16(%ebp),%esi\n\t"
321                    "movl %esp,%edi\n\t"
322                    "cld\n\t"
323                    "rep; movsl\n"
324                    "1:\tcall *8(%ebp)\n\t"
325                    "leal -8(%ebp),%esp\n\t"
326                    "popl %edi\n\t"
327                    __ASM_CFI(".cfi_same_value %edi\n\t")
328                    "popl %esi\n\t"
329                    __ASM_CFI(".cfi_same_value %esi\n\t")
330                    "popl %ebp\n\t"
331                    __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
332                    __ASM_CFI(".cfi_same_value %ebp\n\t")
333                    "ret" )
334
335
336 /***********************************************************************
337  *           relay_call_from_16_no_debug
338  *
339  * Same as relay_call_from_16 but doesn't print any debug information.
340  */
341 static int relay_call_from_16_no_debug( void *entry_point, unsigned char *args16, CONTEXT *context,
342                                         const CALLFROM16 *call )
343 {
344     unsigned int i, j, nb_args = 0;
345     int args32[20];
346
347     /* look for the ret instruction */
348     for (j = 0; j < sizeof(call->ret)/sizeof(call->ret[0]); j++)
349         if (call->ret[j] == 0xca66 || call->ret[j] == 0xcb66) break;
350
351     if (call->ret[j] == 0xcb66)  /* cdecl */
352     {
353         for (i = 0; i < 20; i++, nb_args++)
354         {
355             int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
356
357             if (type == ARG_NONE) break;
358             switch(type)
359             {
360             case ARG_WORD:
361                 args32[nb_args] = *(WORD *)args16;
362                 args16 += sizeof(WORD);
363                 break;
364             case ARG_SWORD:
365                 args32[nb_args] = *(short *)args16;
366                 args16 += sizeof(WORD);
367                 break;
368             case ARG_LONG:
369             case ARG_SEGSTR:
370                 args32[nb_args] = *(int *)args16;
371                 args16 += sizeof(int);
372                 break;
373             case ARG_PTR:
374             case ARG_STR:
375                 args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 );
376                 args16 += sizeof(SEGPTR);
377                 break;
378             case ARG_VARARG:
379                 args32[nb_args] = (int)args16;
380                 break;
381             default:
382                 break;
383             }
384         }
385     }
386     else  /* not cdecl */
387     {
388         /* Start with the last arg */
389         args16 += call->ret[j + 1];
390         for (i = 0; i < 20; i++, nb_args++)
391         {
392             int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
393
394             if (type == ARG_NONE) break;
395             switch(type)
396             {
397             case ARG_WORD:
398                 args16 -= sizeof(WORD);
399                 args32[nb_args] = *(WORD *)args16;
400                 break;
401             case ARG_SWORD:
402                 args16 -= sizeof(WORD);
403                 args32[nb_args] = *(short *)args16;
404                 break;
405             case ARG_LONG:
406             case ARG_SEGSTR:
407                 args16 -= sizeof(int);
408                 args32[nb_args] = *(int *)args16;
409                 break;
410             case ARG_PTR:
411             case ARG_STR:
412                 args16 -= sizeof(SEGPTR);
413                 args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 );
414                 break;
415             default:
416                 break;
417             }
418         }
419     }
420
421     if (!j)  /* register function */
422         args32[nb_args++] = (int)context;
423
424     SYSLEVEL_CheckNotLevel( 2 );
425
426     return call_entry_point( entry_point, nb_args, args32 );
427 }
428
429
430 /***********************************************************************
431  *           relay_call_from_16
432  *
433  * Replacement for the 16-bit relay functions when relay debugging is on.
434  */
435 int relay_call_from_16( void *entry_point, unsigned char *args16, CONTEXT *context )
436 {
437     STACK16FRAME *frame;
438     WORD ordinal;
439     unsigned int i, j, nb_args = 0;
440     int ret_val, args32[20];
441     char module[10], func[64];
442     const CALLFROM16 *call;
443
444     frame = CURRENT_STACK16;
445     call = get_entry_point( frame, module, func, &ordinal );
446     if (!TRACE_ON(relay) || !RELAY_ShowDebugmsgRelay( module, ordinal, func ))
447         return relay_call_from_16_no_debug( entry_point, args16, context, call );
448
449     DPRINTF( "%04x:Call %s.%d: %s(",GetCurrentThreadId(), module, ordinal, func );
450
451     /* look for the ret instruction */
452     for (j = 0; j < sizeof(call->ret)/sizeof(call->ret[0]); j++)
453         if (call->ret[j] == 0xca66 || call->ret[j] == 0xcb66) break;
454
455     if (call->ret[j] == 0xcb66)  /* cdecl */
456     {
457         for (i = 0; i < 20; i++, nb_args++)
458         {
459             int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
460
461             if (type == ARG_NONE) break;
462             if (i) DPRINTF( "," );
463             switch(type)
464             {
465             case ARG_WORD:
466                 DPRINTF( "%04x", *(WORD *)args16 );
467                 args32[nb_args] = *(WORD *)args16;
468                 args16 += sizeof(WORD);
469                 break;
470             case ARG_SWORD:
471                 DPRINTF( "%04x", *(WORD *)args16 );
472                 args32[nb_args] = *(short *)args16;
473                 args16 += sizeof(WORD);
474                 break;
475             case ARG_LONG:
476                 DPRINTF( "%08x", *(int *)args16 );
477                 args32[nb_args] = *(int *)args16;
478                 args16 += sizeof(int);
479                 break;
480             case ARG_PTR:
481                 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
482                 args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 );
483                 args16 += sizeof(SEGPTR);
484                 break;
485             case ARG_STR:
486                 DPRINTF( "%08x %s", *(int *)args16,
487                          debugstr_a( MapSL(*(SEGPTR *)args16 )));
488                 args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 );
489                 args16 += sizeof(int);
490                 break;
491             case ARG_SEGSTR:
492                 DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16,
493                          debugstr_a( MapSL(*(SEGPTR *)args16 )) );
494                 args32[nb_args] = *(SEGPTR *)args16;
495                 args16 += sizeof(SEGPTR);
496                 break;
497             case ARG_VARARG:
498                 DPRINTF( "..." );
499                 args32[nb_args] = (int)args16;
500                 break;
501             default:
502                 break;
503             }
504         }
505     }
506     else  /* not cdecl */
507     {
508         /* Start with the last arg */
509         args16 += call->ret[j + 1];
510         for (i = 0; i < 20; i++, nb_args++)
511         {
512             int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
513
514             if (type == ARG_NONE) break;
515             if (i) DPRINTF( "," );
516             switch(type)
517             {
518             case ARG_WORD:
519                 args16 -= sizeof(WORD);
520                 args32[nb_args] = *(WORD *)args16;
521                 DPRINTF( "%04x", *(WORD *)args16 );
522                 break;
523             case ARG_SWORD:
524                 args16 -= sizeof(WORD);
525                 args32[nb_args] = *(short *)args16;
526                 DPRINTF( "%04x", *(WORD *)args16 );
527                 break;
528             case ARG_LONG:
529                 args16 -= sizeof(int);
530                 args32[nb_args] = *(int *)args16;
531                 DPRINTF( "%08x", *(int *)args16 );
532                 break;
533             case ARG_PTR:
534                 args16 -= sizeof(SEGPTR);
535                 args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 );
536                 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
537                 break;
538             case ARG_STR:
539                 args16 -= sizeof(int);
540                 args32[nb_args] = (int)MapSL( *(SEGPTR *)args16 );
541                 DPRINTF( "%08x %s", *(int *)args16,
542                          debugstr_a( MapSL(*(SEGPTR *)args16 )));
543                 break;
544             case ARG_SEGSTR:
545                 args16 -= sizeof(SEGPTR);
546                 args32[nb_args] = *(SEGPTR *)args16;
547                 DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16,
548                          debugstr_a( MapSL(*(SEGPTR *)args16 )) );
549                 break;
550             case ARG_VARARG:
551                 DPRINTF( "..." );
552                 args32[nb_args] = (int)args16;
553                 break;
554             default:
555                 break;
556             }
557         }
558     }
559
560     DPRINTF( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
561
562     if (!j)  /* register function */
563     {
564         args32[nb_args++] = (int)context;
565         DPRINTF("     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08x\n",
566                 (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
567                 (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
568                 (WORD)context->SegEs, context->EFlags );
569     }
570
571     SYSLEVEL_CheckNotLevel( 2 );
572
573     ret_val = call_entry_point( entry_point, nb_args, args32 );
574
575     SYSLEVEL_CheckNotLevel( 2 );
576
577     DPRINTF( "%04x:Ret  %s.%d: %s() ",GetCurrentThreadId(), module, ordinal, func );
578     if (!j)  /* register function */
579     {
580         DPRINTF("retval=none ret=%04x:%04x ds=%04x\n",
581                 (WORD)context->SegCs, LOWORD(context->Eip), (WORD)context->SegDs);
582         DPRINTF("     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08x\n",
583                 (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
584                 (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
585                 (WORD)context->SegEs, context->EFlags );
586     }
587     else
588     {
589         frame = CURRENT_STACK16;  /* might have be changed by the entry point */
590         if (j == 1)  /* 16-bit return sequence */
591             DPRINTF( "retval=%04x ret=%04x:%04x ds=%04x\n",
592                      ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
593         else
594             DPRINTF( "retval=%08x ret=%04x:%04x ds=%04x\n",
595                      ret_val, frame->cs, frame->ip, frame->ds );
596     }
597     return ret_val;
598 }
599
600 /**********************************************************************
601  *          RELAY_GetPointer
602  *
603  * Get pointer to stack block when given esp pointing to 16-bit stack
604  * inside relay data segment.
605  */
606 static RELAY_Stack16 *RELAY_GetPointer( DWORD offset )
607 {
608     offset = offset / sizeof(RELAY_Stack16) * sizeof(RELAY_Stack16);
609     return MapSL(MAKESEGPTR(DOSVM_dpmi_segments->relay_data_sel, offset));
610 }
611
612
613 /**********************************************************************
614  *          RELAY_MakeShortContext
615  *
616  * Allocate separate 16-bit stack, make stack pointer point to this
617  * stack and make code pointer point to stub that restores everything.
618  * So, after this routine, SS and CS are guaranteed to be 16-bit.
619  *
620  * Note: This might be called from signal handler, so the stack
621  *       allocation algorithm must be signal safe.
622  */
623 static void RELAY_MakeShortContext( CONTEXT *context )
624 {
625     DWORD offset = offsetof(RELAY_Stack16, stack_top);
626     RELAY_Stack16 *stack = RELAY_GetPointer( 0 );
627
628     while (stack->inuse && offset < DOSVM_RELAY_DATA_SIZE) {
629         stack++;
630         offset += sizeof(RELAY_Stack16);
631     }
632
633     if (offset >= DOSVM_RELAY_DATA_SIZE)
634         ERR( "Too many nested interrupts!\n" );
635
636     stack->inuse = 1;
637     stack->eip = context->Eip;
638     stack->seg_cs = context->SegCs;
639     stack->esp = context->Esp;
640     stack->seg_ss = context->SegSs;
641
642     stack->stack_bottom = RELAY_MAGIC;
643     stack->stack_top = RELAY_MAGIC;
644
645     context->SegSs = DOSVM_dpmi_segments->relay_data_sel;
646     context->Esp = offset;
647     context->SegCs = DOSVM_dpmi_segments->relay_code_sel;
648     context->Eip = 3;
649 }
650
651
652 /**********************************************************************
653  *          RELAY_RelayStub
654  *
655  * This stub is called by __wine_call_from_16_regs in order to marshall
656  * relay parameters.
657  */
658 static void __stdcall RELAY_RelayStub( DOSRELAY proc, unsigned char *args, CONTEXT *context )
659 {
660     if (proc)
661     {
662         RELAY_Stack16 *stack = RELAY_GetPointer( context->Esp );
663
664         DWORD old_seg_cs = context->SegCs;
665         DWORD old_eip    = context->Eip;
666         DWORD old_seg_ss = context->SegSs;
667         DWORD old_esp    = context->Esp;
668
669         context->SegCs = stack->seg_cs;
670         context->Eip   = stack->eip;
671         context->SegSs = stack->seg_ss;
672         context->Esp   = stack->esp;
673
674         proc( context, *(LPVOID *)args );
675
676         stack->seg_cs = context->SegCs;
677         stack->eip    = context->Eip;
678         stack->seg_ss = context->SegSs;
679         stack->esp    = context->Esp;
680
681         context->SegCs = old_seg_cs;
682         context->Eip   = old_eip;
683         context->SegSs = old_seg_ss;
684         context->Esp   = old_esp;
685     }
686 }
687
688
689 /**********************************************************************
690  *          DOSVM_RelayHandler
691  *
692  * Restore saved code and stack pointers and release stack block.
693  */
694 void DOSVM_RelayHandler( CONTEXT *context )
695 {
696     RELAY_Stack16 *stack = RELAY_GetPointer( context->Esp );
697
698     context->SegSs = stack->seg_ss;
699     context->Esp = stack->esp;
700     context->SegCs = stack->seg_cs;
701     context->Eip = stack->eip;
702
703     if (!stack->inuse ||
704         stack->stack_bottom != RELAY_MAGIC ||
705         stack->stack_top != RELAY_MAGIC)
706         ERR( "Stack corrupted!\n" );
707
708     stack->inuse = 0;
709 }
710
711
712 /**********************************************************************
713  *          DOSVM_BuildCallFrame
714  *
715  * Modifies the context so that return to context calls DOSRELAY and
716  * only after return from DOSRELAY the original context will be returned to.
717  */
718 void DOSVM_BuildCallFrame( CONTEXT *context, DOSRELAY relay, LPVOID data )
719 {
720     WORD  code_sel = DOSVM_dpmi_segments->relay_code_sel;
721
722     /*
723      * Allocate separate stack for relay call.
724      */
725     RELAY_MakeShortContext( context );
726
727     /*
728      * Build call frame.
729      */
730     PUSH_WORD16( context, HIWORD(data) );            /* argument.hiword */
731     PUSH_WORD16( context, LOWORD(data) );            /* argument.loword */
732     PUSH_WORD16( context, context->SegCs );          /* STACK16FRAME.cs */
733     PUSH_WORD16( context, LOWORD(context->Eip) );    /* STACK16FRAME.ip */
734     PUSH_WORD16( context, LOWORD(context->Ebp) );    /* STACK16FRAME.bp */
735     PUSH_WORD16( context, HIWORD(relay) );           /* STACK16FRAME.entry_point.hiword */
736     PUSH_WORD16( context, LOWORD(relay) );           /* STACK16FRAME.entry_point.loword */
737     PUSH_WORD16( context, 0 );                       /* STACK16FRAME.entry_ip */
738     PUSH_WORD16( context, HIWORD(RELAY_RelayStub) ); /* STACK16FRAME.relay.hiword */
739     PUSH_WORD16( context, LOWORD(RELAY_RelayStub) ); /* STACK16FRAME.relay.loword */
740     PUSH_WORD16( context, 0 );                       /* STACK16FRAME.module_cs.hiword */
741     PUSH_WORD16( context, code_sel );                /* STACK16FRAME.module_cs.loword */
742     PUSH_WORD16( context, 0 );                       /* STACK16FRAME.callfrom_ip.hiword */
743     PUSH_WORD16( context, 0 );                       /* STACK16FRAME.callfrom_ip.loword */
744
745     /*
746      * Adjust code pointer.
747      */
748     context->SegCs = wine_get_cs();
749     context->Eip = (DWORD)__wine_call_from_16_regs;
750 }