if1632/callback.c

   1 static char RCSId[] = "$Id: wine.c,v 1.2 1993/07/04 04:04:21 root Exp root $";
   2 static char Copyright[] = "Copyright  Robert J. Amstadt, 1993";
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include "windows.h"
   7 #include "callback.h"
   8 #include "wine.h"
   9 #include "segmem.h"
  10 #include <setjmp.h>
  11
  12 extern SEGDESC Segments[];
  13 extern unsigned short IF1632_Saved16_ss;
  14 extern unsigned long  IF1632_Saved16_ebp;
  15 extern unsigned long  IF1632_Saved16_esp;
  16 extern unsigned short IF1632_Saved32_ss;
  17 extern unsigned long  IF1632_Saved32_ebp;
  18 extern unsigned long  IF1632_Saved32_esp;
  19
  20 extern struct segment_descriptor_s *MakeProcThunks;
  21
  22 struct thunk_s
  23 {
  24     int used;
  25     unsigned char thunk[10];
  26 };
  27
  28 /**********************************************************************
  29  *                                      PushOn16
  30  */
  31 static void
  32 PushOn16(int size, unsigned int value)
  33 {
  34     char *p = (char *) (((unsigned int)IF1632_Saved16_ss << 16) +
  35                         (IF1632_Saved16_esp & 0xffff));
  36     if (size)
  37     {
  38         unsigned long *lp = (unsigned long *) p - 1;
  39
  40         *lp = value;
  41         IF1632_Saved16_esp -= 4;
  42     }
  43     else
  44     {
  45         unsigned short *sp = (unsigned short *) p - 1;
  46
  47         *sp = value;
  48         IF1632_Saved16_esp -= 2;
  49     }
  50 }
  51
  52 /**********************************************************************
  53  *                                      FindDataSegmentForCode
  54  */
  55 static unsigned short
  56 FindDataSegmentForCode(unsigned long csip)
  57 {
  58     unsigned int seg_idx;
  59
  60     seg_idx = (unsigned short) (csip >> 19);
  61     return Segments[seg_idx].owner;
  62 }
  63
  64 /**********************************************************************
  65  *                                      CallBack16
  66  */
  67 int
  68 CallBack16(void *func, int n_args, ...)
  69 {
  70     va_list ap;
  71     int i;
  72     int arg_type, arg_value;
  73
  74     va_start(ap, n_args);
  75
  76     for (i = 0; i < n_args; i++)
  77     {
  78         arg_type = va_arg(ap, int);
  79         arg_value = va_arg(ap, int);
  80         PushOn16(arg_type, arg_value);
  81     }
  82
  83     va_end(ap);
  84
  85     return CallTo16((unsigned int) func,
  86                     FindDataSegmentForCode((unsigned long) func));
  87 }
  88
  89 /**********************************************************************
  90  *                                      CALLBACK_MakeProcInstance
  91  */
  92 void *
  93 CALLBACK_MakeProcInstance(void *func, int instance)
  94 {
  95     int handle;
  96     void *new_func;
  97     struct thunk_s *tp;
  98     int i;
  99
 100     tp = (struct thunk_s *) MakeProcThunks->base_addr;
 101     for (i = 0; i < 0x10000 / sizeof(*tp); i++, tp++)
 102         if (!tp->used)
 103             break;
 104
 105     if (tp->used)
 106         return (void *) 0;
 107
 108     tp->thunk[0] = 0xb8;
 109     tp->thunk[1] = (unsigned char) instance;
 110     tp->thunk[2] = (unsigned char) (instance >> 8);
 111     tp->thunk[3] = 0x8e;
 112     tp->thunk[4] = 0xd8;
 113     tp->thunk[5] = 0xea;
 114     memcpy(&tp->thunk[6], &func, 4);
 115     tp->used = 1;
 116
 117     return tp->thunk;
 118 }
 119
 120 /**********************************************************************
 121  *                                      FreeProcInstance (KERNEL.52)
 122  */
 123 void FreeProcInstance(FARPROC func)
 124 {
 125     int handle;
 126     void *new_func;
 127     struct thunk_s *tp;
 128     int i;
 129
 130     tp = (struct thunk_s *) MakeProcThunks->base_addr;
 131     for (i = 0; i < 0x10000 / sizeof(*tp); i++, tp++)
 132     {
 133         if ((void *) tp->thunk == (void *) func)
 134         {
 135             tp->used = 0;
 136             break;
 137         }
 138     }
 139 }
 140
 141 /**********************************************************************
 142  *                                      CallWindowProc    (USER.122)
 143  */
 144 LONG CallWindowProc( FARPROC func, HWND hwnd, WORD message,
 145                      WORD wParam, LONG lParam )
 146 {
 147     SpyMessage(hwnd, message, wParam, lParam);
 148
 149     if (HIWORD((LONG)func) == WINE_CODE_SELECTOR)
 150     {
 151         static struct dll_table_entry_s *user_tab = NULL;
 152         void *address = (void *) ((LONG) func & 0xffff);
 153
 154         if (user_tab == NULL)
 155             user_tab = FindDLLTable("USER");
 156
 157         /* DefWindowProc */
 158         if (user_tab[104].address == address)
 159             return DefWindowProc(hwnd, message, wParam, lParam);
 160
 161         /* DefDlgProc */
 162         else if (user_tab[308].address == address)
 163             return DefDlgProc(hwnd, message, wParam, lParam);
 164
 165         /* DefMDIChildProc */
 166         else if (user_tab[447].address == address)
 167             return DefMDIChildProc(hwnd, message, wParam, lParam);
 168
 169         /* default */
 170         else
 171         {
 172             fprintf(stderr, "wine: Unknown wine callback %08x\n", func);
 173             exit(1);
 174         }
 175     }
 176     else if (Is16bitAddress(func))
 177     {
 178 #ifdef DEBUG_CALLBACK
 179         printf("CallWindowProc // 16bit func=%08X !\n", func);
 180 #endif
 181         PushOn16( CALLBACK_SIZE_WORD, hwnd );
 182         PushOn16( CALLBACK_SIZE_WORD, message );
 183         PushOn16( CALLBACK_SIZE_WORD, wParam );
 184         PushOn16( CALLBACK_SIZE_LONG, lParam );
 185         return CallTo16((unsigned int) func,
 186                         FindDataSegmentForCode((unsigned long) func));
 187     }
 188     else
 189     {
 190 #ifdef DEBUG_CALLBACK
 191         printf("CallWindowProc // 32bit func=%08X !\n", func);
 192 #endif
 193         return (*func)(hwnd, message, wParam, lParam);
 194     }
 195 }
 196
 197 /**********************************************************************
 198  *                                      CallLineDDAProc
 199  */
 200 void CallLineDDAProc(FARPROC func, short xPos, short yPos, long lParam)
 201 {
 202     if (Is16bitAddress(func))
 203     {
 204         PushOn16( CALLBACK_SIZE_WORD, xPos );
 205         PushOn16( CALLBACK_SIZE_WORD, yPos );
 206         PushOn16( CALLBACK_SIZE_LONG, lParam );
 207         CallTo16((unsigned int) func,
 208                  FindDataSegmentForCode((unsigned long) func));
 209     }
 210     else
 211     {
 212         (*func)(xPos, yPos, lParam);
 213     }
 214 }
 215
 216 /**********************************************************************
 217  *                                      CallHookProc
 218  */
 219 DWORD CallHookProc( HOOKPROC func, short code, WPARAM wParam, LPARAM lParam )
 220 {
 221     if (Is16bitAddress(func))
 222     {
 223         PushOn16( CALLBACK_SIZE_WORD, code );
 224         PushOn16( CALLBACK_SIZE_WORD, wParam );
 225         PushOn16( CALLBACK_SIZE_LONG, lParam );
 226         return CallTo16((unsigned int) func,
 227                         FindDataSegmentForCode((unsigned long) func));
 228     }
 229     else
 230     {
 231         return (*func)( code, wParam, lParam );
 232     }
 233 }
 234
 235 /**********************************************************************
 236  *                                      CallGrayStringProc
 237  */
 238 BOOL CallGrayStringProc(FARPROC func, HDC hdc, LPARAM lParam, INT cch )
 239 {
 240     if (Is16bitAddress(func))
 241     {
 242         PushOn16( CALLBACK_SIZE_WORD, hdc );
 243         PushOn16( CALLBACK_SIZE_LONG, lParam );
 244         PushOn16( CALLBACK_SIZE_WORD, cch );
 245         return CallTo16((unsigned int) func,
 246                         FindDataSegmentForCode((unsigned long) func));
 247     }
 248     else
 249     {
 250         return (*func)( hdc, lParam, cch );
 251     }
 252 }
 253
 254 /* ------------------------------------------------------------------------ */
 255 /*
 256  * The following functions realize the Catch/Throw functionality.
 257  * My thought is to use the setjmp, longjmp combination to do the
 258  * major part of this one. All I have to remember, in addition to
 259  * whatever the jmp_buf contains, is the contents of the 16-bit
 260  * sp, bp and ss. I do this by storing them in the structure passed
 261  * to me by the 16-bit program (including my own jmp_buf...).
 262  * Hopefully there isn't any program that modifies the contents!
 263  * Bad thing: I have to save part of the stack, since this will
 264  * get reused on the next call after my return, leaving it in an
 265  * undefined state.
 266  */
 267 #define STACK_DEPTH_16  28
 268
 269 struct special_buffer {
 270         jmp_buf buffer;
 271         long    regs [6];
 272         char    stack_part [STACK_DEPTH_16];
 273 } *sb;
 274
 275 int Catch (LPCATCHBUF cbuf)
 276 {
 277         WORD retval;
 278         jmp_buf *tmp_jmp;
 279         char *stack16 =  (char *) (((unsigned int)IF1632_Saved16_ss << 16) +
 280                 (IF1632_Saved16_esp & 0xffff));
 281
 282         sb = malloc (sizeof (struct special_buffer));
 283
 284         sb -> regs [0] = IF1632_Saved16_esp;
 285         sb -> regs [1] = IF1632_Saved16_ebp;
 286         sb -> regs [2] = IF1632_Saved16_ss & 0xffff;
 287         sb -> regs [3] = IF1632_Saved32_esp;
 288         sb -> regs [4] = IF1632_Saved32_ebp;
 289         sb -> regs [5] = IF1632_Saved32_ss & 0xffff;
 290         memcpy (sb -> stack_part, stack16, STACK_DEPTH_16);
 291         tmp_jmp = &sb -> buffer;
 292         *((struct special_buffer **)cbuf) = sb;
 293
 294         if ((retval = setjmp (*tmp_jmp)))
 295         {
 296                 IF1632_Saved16_esp = sb -> regs [0];
 297                 IF1632_Saved16_ebp = sb -> regs [1];
 298                 IF1632_Saved16_ss = sb -> regs [2] & 0xffff;
 299                 IF1632_Saved32_esp = sb -> regs [3];
 300                 IF1632_Saved32_ebp = sb -> regs [4];
 301                 IF1632_Saved32_ss = sb -> regs [5] & 0xffff;
 302                 stack16 = (char *) (((unsigned int)IF1632_Saved16_ss << 16) +
 303                                 (IF1632_Saved16_esp & 0xffff));
 304
 305                 memcpy (stack16, sb -> stack_part, STACK_DEPTH_16);
 306 #ifdef  DEBUG_CATCH
 307                 printf ("Been thrown here: %d, retval = %d\n", sb, retval);
 308 #endif
 309                 free ((void *) sb);
 310                 return (retval);
 311         } else {
 312 #ifdef  DEBUG_CATCH
 313                 printf ("Will somtime get thrown here: %d\n", sb);
 314 #endif
 315                 return (retval);
 316         }
 317 }
 318
 319 void Throw (LPCATCHBUF cbuf, int val)
 320 {
 321         sb = *((struct special_buffer **)cbuf);
 322 #ifdef  DEBUG_CATCH
 323         printf ("Throwing to: %d\n", sb);
 324 #endif
 325         longjmp (sb -> buffer, val);
 326 }