?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gameux/tests: Add test of storing and reading game statistics.
[wine.git] / dlls / krnl386.exe16 / relay.c
blob29a36f1df82fd18ccaef48481cdde7ef57c70cbf
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, CONTEXT86 *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, CONTEXT86 *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( CONTEXT86 *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, CONTEXT86 *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( CONTEXT86 *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( CONTEXT86 *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 }
Windows API implementation