urlmon: Fix HttpProtocol behavior when it is called without the BINDF_FROMURLMON...
[wine] / dlls / winedos / interrupts.c
1 /*
2  * Interrupt emulation
3  *
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
23 #include <stdio.h>
24
25 #include "dosexe.h"
26 #include "wine/debug.h"
27 #include "wine/winbase16.h"
28
29 #include "thread.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(int);
32 WINE_DECLARE_DEBUG_CHANNEL(relay);
33
34 #define BCD_TO_BIN(x) ((x&15) + (x>>4)*10)
35 #define BIN_TO_BCD(x) ((x%10) + ((x/10)<<4))
36
37 static void WINAPI DOSVM_Int11Handler(CONTEXT86*);
38 static void WINAPI DOSVM_Int12Handler(CONTEXT86*);
39 static void WINAPI DOSVM_Int17Handler(CONTEXT86*);
40 static void WINAPI DOSVM_Int19Handler(CONTEXT86*);
41 static void WINAPI DOSVM_Int1aHandler(CONTEXT86*);
42 static void WINAPI DOSVM_Int20Handler(CONTEXT86*);
43 static void WINAPI DOSVM_Int29Handler(CONTEXT86*);
44 static void WINAPI DOSVM_Int2aHandler(CONTEXT86*);
45 static void WINAPI DOSVM_Int41Handler(CONTEXT86*);
46 static void WINAPI DOSVM_Int4bHandler(CONTEXT86*);
47 static void WINAPI DOSVM_Int5cHandler(CONTEXT86*);
48
49 static FARPROC16     DOSVM_Vectors16[256];
50 static FARPROC48     DOSVM_Vectors48[256];
51 static const INTPROC DOSVM_VectorsBuiltin[] =
52 {
53   /* 00 */ 0,                  0,                  0,                  0,
54   /* 04 */ 0,                  0,                  0,                  0,
55   /* 08 */ DOSVM_Int08Handler, DOSVM_Int09Handler, 0,                  0,
56   /* 0C */ 0,                  0,                  0,                  0,
57   /* 10 */ DOSVM_Int10Handler, DOSVM_Int11Handler, DOSVM_Int12Handler, DOSVM_Int13Handler,
58   /* 14 */ 0,                  DOSVM_Int15Handler, DOSVM_Int16Handler, DOSVM_Int17Handler,
59   /* 18 */ 0,                  DOSVM_Int19Handler, DOSVM_Int1aHandler, 0,
60   /* 1C */ 0,                  0,                  0,                  0,
61   /* 20 */ DOSVM_Int20Handler, DOSVM_Int21Handler, 0,                  0,
62   /* 24 */ 0,                  DOSVM_Int25Handler, DOSVM_Int26Handler, 0,
63   /* 28 */ 0,                  DOSVM_Int29Handler, DOSVM_Int2aHandler, 0,
64   /* 2C */ 0,                  0,                  0,                  DOSVM_Int2fHandler,
65   /* 30 */ 0,                  DOSVM_Int31Handler, 0,                  DOSVM_Int33Handler,
66   /* 34 */ DOSVM_Int34Handler, DOSVM_Int35Handler, DOSVM_Int36Handler, DOSVM_Int37Handler,
67   /* 38 */ DOSVM_Int38Handler, DOSVM_Int39Handler, DOSVM_Int3aHandler, DOSVM_Int3bHandler,
68   /* 3C */ DOSVM_Int3cHandler, DOSVM_Int3dHandler, DOSVM_Int3eHandler, 0,
69   /* 40 */ 0,                  DOSVM_Int41Handler, 0,                  0,
70   /* 44 */ 0,                  0,                  0,                  0,
71   /* 48 */ 0,                  0,                  0,                  DOSVM_Int4bHandler,
72   /* 4C */ 0,                  0,                  0,                  0,
73   /* 50 */ 0,                  0,                  0,                  0,
74   /* 54 */ 0,                  0,                  0,                  0,
75   /* 58 */ 0,                  0,                  0,                  0,
76   /* 5C */ DOSVM_Int5cHandler, 0,                  0,                  0,
77   /* 60 */ 0,                  0,                  0,                  0,
78   /* 64 */ 0,                  0,                  0,                  DOSVM_Int67Handler
79 };
80
81
82 /*
83  * Sizes of real mode and protected mode interrupt stubs.
84  */
85 #define DOSVM_STUB_RM   4
86 #define DOSVM_STUB_PM16 5
87 #define DOSVM_STUB_PM48 6
88
89
90 /**********************************************************************
91  *         DOSVM_GetRMVector
92  *
93  * Return pointer to real mode interrupt vector. These are not at fixed 
94  * location because those Win16 programs that do not use any real mode 
95  * code have protected NULL pointer catching block at low linear memory 
96  * and interrupt vectors have been moved to another location.
97  */
98 static FARPROC16* DOSVM_GetRMVector( BYTE intnum )
99 {
100     LDT_ENTRY entry;
101     FARPROC16 proc;
102
103     proc = GetProcAddress16( GetModuleHandle16( "KERNEL" ), 
104                              (LPCSTR)(ULONG_PTR)183 );
105     wine_ldt_get_entry( LOWORD(proc), &entry );
106
107     return (FARPROC16*)wine_ldt_get_base( &entry ) + intnum;
108 }
109
110
111 /**********************************************************************
112  *         DOSVM_IsIRQ
113  *
114  * Return TRUE if interrupt is an IRQ.
115  */
116 static BOOL DOSVM_IsIRQ( BYTE intnum )
117 {
118     if (intnum >= 0x08 && intnum <= 0x0f)
119         return TRUE;
120
121     if (intnum >= 0x70 && intnum <= 0x77)
122         return TRUE;
123
124     return FALSE;
125 }
126
127
128 /**********************************************************************
129  *         DOSVM_DefaultHandler
130  *
131  * Default interrupt handler. This will be used to emulate all
132  * interrupts that don't have their own interrupt handler.
133  */
134 static void WINAPI DOSVM_DefaultHandler( CONTEXT86 *context )
135 {
136 }
137
138
139 /**********************************************************************
140  *         DOSVM_GetBuiltinHandler
141  *
142  * Return Wine interrupt handler procedure for a given interrupt.
143  */
144 static INTPROC DOSVM_GetBuiltinHandler( BYTE intnum )
145 {
146     if (intnum < sizeof(DOSVM_VectorsBuiltin)/sizeof(INTPROC)) {
147         INTPROC proc = DOSVM_VectorsBuiltin[intnum];
148         if (proc)
149             return proc;
150     }
151
152     WARN("int%x not implemented, returning dummy handler\n", intnum );
153
154     if (DOSVM_IsIRQ(intnum))
155         return DOSVM_AcknowledgeIRQ;
156
157     return DOSVM_DefaultHandler;
158 }
159
160
161 /**********************************************************************
162  *          DOSVM_IntProcRelay
163  *
164  * Simple DOSRELAY that interprets its argument as INTPROC and calls it.
165  */
166 static void DOSVM_IntProcRelay( CONTEXT86 *context, LPVOID data )
167 {
168     INTPROC proc = (INTPROC)data;
169     proc(context);
170 }
171
172
173 /**********************************************************************
174  *          DOSVM_PrepareIRQ
175  *
176  */
177 static void DOSVM_PrepareIRQ( CONTEXT86 *context, BOOL isbuiltin )
178 {
179     /* Disable virtual interrupts. */
180     NtCurrentTeb()->dpmi_vif = 0;
181
182     if (!isbuiltin)
183     {
184         DWORD *stack = CTX_SEG_OFF_TO_LIN(context, 
185                                           context->SegSs,
186                                           context->Esp);
187
188         /* Push return address to stack. */
189         *(--stack) = context->SegCs;
190         *(--stack) = context->Eip;
191         context->Esp += -8;
192
193         /* Jump to enable interrupts stub. */
194         context->SegCs = DOSVM_dpmi_segments->relay_code_sel;
195         context->Eip   = 5;
196     }
197 }
198
199
200 /**********************************************************************
201  *          DOSVM_PushFlags
202  *
203  * This routine is used to make default int25 and int26 handlers leave the 
204  * original eflags into stack. In order to do this, stack is manipulated
205  * so that it actually contains two copies of eflags, one of which is
206  * popped during return from interrupt handler.
207  */
208 static void DOSVM_PushFlags( CONTEXT86 *context, BOOL islong, BOOL isstub )
209 {
210     if (islong)
211     {
212         DWORD *stack = CTX_SEG_OFF_TO_LIN(context, 
213                                           context->SegSs, 
214                                           context->Esp);
215         context->Esp += -4; /* One item will be added to stack. */
216
217         if (isstub)
218         {
219             DWORD ip = stack[0];
220             DWORD cs = stack[1];
221             stack += 2; /* Pop ip and cs. */
222             *(--stack) = context->EFlags;
223             *(--stack) = cs;
224             *(--stack) = ip;
225         }
226         else
227             *(--stack) = context->EFlags;            
228     }
229     else
230     {
231         WORD *stack = CTX_SEG_OFF_TO_LIN(context, 
232                                          context->SegSs, 
233                                          context->Esp);
234         ADD_LOWORD( context->Esp, -2 ); /* One item will be added to stack. */
235
236         if (isstub)
237         {
238             WORD ip = stack[0];
239             WORD cs = stack[1];
240             stack += 2; /* Pop ip and cs. */
241             *(--stack) = LOWORD(context->EFlags);
242             *(--stack) = cs;
243             *(--stack) = ip;
244         }
245         else
246             *(--stack) = LOWORD(context->EFlags);
247     }
248 }
249
250
251 /**********************************************************************
252  *         DOSVM_EmulateInterruptPM
253  *
254  * Emulate software interrupt in 16-bit or 32-bit protected mode.
255  * Called from signal handler when intXX opcode is executed. 
256  *
257  * Pushes interrupt frame to stack and changes instruction 
258  * pointer to interrupt handler.
259  */
260 void WINAPI DOSVM_EmulateInterruptPM( CONTEXT86 *context, BYTE intnum ) 
261 {
262     TRACE_(relay)("Call DOS int 0x%02x ret=%04x:%08x\n"
263                   "  eax=%08x ebx=%08x ecx=%08x edx=%08x\n"
264                   "  esi=%08x edi=%08x ebp=%08x esp=%08x \n"
265                   "  ds=%04x es=%04x fs=%04x gs=%04x ss=%04x flags=%08x\n",
266                   intnum, context->SegCs, context->Eip,
267                   context->Eax, context->Ebx, context->Ecx, context->Edx,
268                   context->Esi, context->Edi, context->Ebp, context->Esp,
269                   context->SegDs, context->SegEs, context->SegFs, context->SegGs,
270                   context->SegSs, context->EFlags );
271
272     if (context->SegCs == DOSVM_dpmi_segments->dpmi_sel)
273     {
274         DOSVM_BuildCallFrame( context, 
275                               DOSVM_IntProcRelay,
276                               DOSVM_RawModeSwitchHandler );
277     }
278     else if (context->SegCs == DOSVM_dpmi_segments->relay_code_sel)
279     {
280         /*
281          * This must not be called using DOSVM_BuildCallFrame.
282          */
283         DOSVM_RelayHandler( context );
284     }
285     else if (context->SegCs == DOSVM_dpmi_segments->int48_sel)
286     {
287         /* Restore original flags stored into the stack by the caller. */
288         DWORD *stack = CTX_SEG_OFF_TO_LIN(context, 
289                                           context->SegSs, context->Esp);
290         context->EFlags = stack[2];
291
292         if (intnum != context->Eip / DOSVM_STUB_PM48)
293             WARN( "interrupt stub has been modified "
294                   "(interrupt is %02x, interrupt stub is %02x)\n",
295                   intnum, context->Eip/DOSVM_STUB_PM48 );
296
297         TRACE( "builtin interrupt %02x has been branched to\n", intnum );
298
299         if (intnum == 0x25 || intnum == 0x26)
300             DOSVM_PushFlags( context, TRUE, TRUE );
301
302         DOSVM_BuildCallFrame( context, 
303                               DOSVM_IntProcRelay,
304                               DOSVM_GetBuiltinHandler(intnum) );
305     }
306     else if (context->SegCs == DOSVM_dpmi_segments->int16_sel)
307     {
308         /* Restore original flags stored into the stack by the caller. */
309         WORD *stack = CTX_SEG_OFF_TO_LIN(context, 
310                                          context->SegSs, context->Esp);
311         context->EFlags = (DWORD)MAKELONG( stack[2], HIWORD(context->EFlags) );
312
313         if (intnum != context->Eip / DOSVM_STUB_PM16)
314             WARN( "interrupt stub has been modified "
315                   "(interrupt is %02x, interrupt stub is %02x)\n",
316                   intnum, context->Eip/DOSVM_STUB_PM16 );
317
318         TRACE( "builtin interrupt %02x has been branched to\n", intnum );
319
320         if (intnum == 0x25 || intnum == 0x26)
321             DOSVM_PushFlags( context, FALSE, TRUE );
322
323         DOSVM_BuildCallFrame( context, 
324                               DOSVM_IntProcRelay, 
325                               DOSVM_GetBuiltinHandler(intnum) );
326     }
327     else
328     {
329         DOSVM_HardwareInterruptPM( context, intnum );
330     }
331 }
332
333
334 /**********************************************************************
335  *         DOSVM_HardwareInterruptPM
336  *
337  * Emulate call to interrupt handler in 16-bit or 32-bit protected mode.
338  *
339  * Pushes interrupt frame to stack and changes instruction 
340  * pointer to interrupt handler.
341  */
342 void DOSVM_HardwareInterruptPM( CONTEXT86 *context, BYTE intnum ) 
343 {
344     if(DOSVM_IsDos32())
345     {
346         FARPROC48 addr = DOSVM_GetPMHandler48( intnum );
347         
348         if (addr.selector == DOSVM_dpmi_segments->int48_sel)
349         {
350             TRACE( "builtin interrupt %02x has been invoked "
351                    "(through vector %02x)\n",
352                    addr.offset / DOSVM_STUB_PM48, intnum );
353
354             if (intnum == 0x25 || intnum == 0x26)
355                 DOSVM_PushFlags( context, TRUE, FALSE );
356             else if (DOSVM_IsIRQ(intnum))
357                 DOSVM_PrepareIRQ( context, TRUE );
358
359             DOSVM_BuildCallFrame( context,
360                                   DOSVM_IntProcRelay,
361                                   DOSVM_GetBuiltinHandler(
362                                       addr.offset/DOSVM_STUB_PM48 ) );
363         }
364         else
365         {
366             DWORD *stack;
367             
368             TRACE( "invoking hooked interrupt %02x at %04x:%08x\n",
369                    intnum, addr.selector, addr.offset );
370             
371             if (DOSVM_IsIRQ(intnum))
372                 DOSVM_PrepareIRQ( context, FALSE );
373
374             /* Push the flags and return address on the stack */
375             stack = CTX_SEG_OFF_TO_LIN(context, context->SegSs, context->Esp);
376             *(--stack) = context->EFlags;
377             *(--stack) = context->SegCs;
378             *(--stack) = context->Eip;
379             context->Esp += -12;
380
381             /* Jump to the interrupt handler */
382             context->SegCs  = addr.selector;
383             context->Eip = addr.offset;
384         }
385     }
386     else
387     {
388         FARPROC16 addr = DOSVM_GetPMHandler16( intnum );
389
390         if (SELECTOROF(addr) == DOSVM_dpmi_segments->int16_sel)
391         {
392             TRACE( "builtin interrupt %02x has been invoked "
393                    "(through vector %02x)\n", 
394                    OFFSETOF(addr)/DOSVM_STUB_PM16, intnum );
395
396             if (intnum == 0x25 || intnum == 0x26)
397                 DOSVM_PushFlags( context, FALSE, FALSE );
398             else if (DOSVM_IsIRQ(intnum))
399                 DOSVM_PrepareIRQ( context, TRUE );
400
401             DOSVM_BuildCallFrame( context, 
402                                   DOSVM_IntProcRelay,
403                                   DOSVM_GetBuiltinHandler(
404                                       OFFSETOF(addr)/DOSVM_STUB_PM16 ) );
405         }
406         else
407         {
408             TRACE( "invoking hooked interrupt %02x at %04x:%04x\n", 
409                    intnum, SELECTOROF(addr), OFFSETOF(addr) );
410
411             if (DOSVM_IsIRQ(intnum))
412                 DOSVM_PrepareIRQ( context, FALSE );
413
414             /* Push the flags and return address on the stack */
415             PUSH_WORD16( context, LOWORD(context->EFlags) );
416             PUSH_WORD16( context, context->SegCs );
417             PUSH_WORD16( context, LOWORD(context->Eip) );
418
419             /* Jump to the interrupt handler */
420             context->SegCs =  HIWORD(addr);
421             context->Eip = LOWORD(addr);
422         }
423     }
424 }
425
426
427 /**********************************************************************
428  *         DOSVM_EmulateInterruptRM
429  *
430  * Emulate software interrupt in real mode.
431  * Called from VM86 emulation when intXX opcode is executed. 
432  *
433  * Either calls directly builtin handler or pushes interrupt frame to 
434  * stack and changes instruction pointer to interrupt handler.
435  *
436  * Returns FALSE if this interrupt was caused by return 
437  * from real mode wrapper.
438  */
439 BOOL WINAPI DOSVM_EmulateInterruptRM( CONTEXT86 *context, BYTE intnum ) 
440 {
441     TRACE_(relay)("Call DOS int 0x%02x ret=%04x:%08x\n"
442                   "  eax=%08x ebx=%08x ecx=%08x edx=%08x\n"
443                   "  esi=%08x edi=%08x ebp=%08x esp=%08x \n"
444                   "  ds=%04x es=%04x fs=%04x gs=%04x ss=%04x flags=%08x\n",
445                   intnum, context->SegCs, context->Eip,
446                   context->Eax, context->Ebx, context->Ecx, context->Edx,
447                   context->Esi, context->Edi, context->Ebp, context->Esp,
448                   context->SegDs, context->SegEs, context->SegFs, context->SegGs,
449                   context->SegSs, context->EFlags );
450
451     /* check for our real-mode hooks */
452     if (intnum == 0x31)
453     {
454         /* is this exit from real-mode wrapper */
455         if (context->SegCs == DOSVM_dpmi_segments->wrap_seg)
456             return FALSE;
457
458         if (DOSVM_CheckWrappers( context ))
459             return TRUE;
460     }
461
462     /* check if the call is from our fake BIOS interrupt stubs */
463     if (context->SegCs==0xf000)
464     {
465         /* Restore original flags stored into the stack by the caller. */
466         WORD *stack = CTX_SEG_OFF_TO_LIN(context, 
467                                          context->SegSs, context->Esp);
468         context->EFlags = (DWORD)MAKELONG( stack[2], HIWORD(context->EFlags) );
469
470         if (intnum != context->Eip / DOSVM_STUB_RM)
471             WARN( "interrupt stub has been modified "
472                   "(interrupt is %02x, interrupt stub is %02x)\n",
473                   intnum, context->Eip/DOSVM_STUB_RM );
474
475         TRACE( "builtin interrupt %02x has been branched to\n", intnum );
476         
477         DOSVM_CallBuiltinHandler( context, intnum );
478
479         /* Real mode stubs use IRET so we must put flags back into stack. */
480         stack[2] = LOWORD(context->EFlags);
481     }
482     else
483     {
484         DOSVM_HardwareInterruptRM( context, intnum );
485     }
486
487     return TRUE;
488 }
489
490
491 /**********************************************************************
492  *         DOSVM_HardwareInterruptRM
493  *
494  * Emulate call to interrupt handler in real mode.
495  *
496  * Either calls directly builtin handler or pushes interrupt frame to 
497  * stack and changes instruction pointer to interrupt handler.
498  */
499 void DOSVM_HardwareInterruptRM( CONTEXT86 *context, BYTE intnum ) 
500 {
501      FARPROC16 handler = DOSVM_GetRMHandler( intnum );
502
503      /* check if the call goes to an unhooked interrupt */
504      if (SELECTOROF(handler) == 0xf000) 
505      {
506          /* if so, call it directly */
507          TRACE( "builtin interrupt %02x has been invoked "
508                 "(through vector %02x)\n", 
509                 OFFSETOF(handler)/DOSVM_STUB_RM, intnum );
510          DOSVM_CallBuiltinHandler( context, OFFSETOF(handler)/DOSVM_STUB_RM );
511      }
512      else 
513      {
514          /* the interrupt is hooked, simulate interrupt in DOS space */ 
515          WORD  flag  = LOWORD( context->EFlags );
516
517          TRACE( "invoking hooked interrupt %02x at %04x:%04x\n", 
518                 intnum, SELECTOROF(handler), OFFSETOF(handler) );
519
520          /* Copy virtual interrupt flag to pushed interrupt flag. */
521          if (context->EFlags & VIF_MASK)
522              flag |= IF_MASK;
523          else 
524              flag &= ~IF_MASK;
525
526          PUSH_WORD16( context, flag );
527          PUSH_WORD16( context, context->SegCs );
528          PUSH_WORD16( context, LOWORD( context->Eip ));
529          
530          context->SegCs = SELECTOROF( handler );
531          context->Eip   = OFFSETOF( handler );
532
533          /* Clear virtual interrupt flag and trap flag. */
534          context->EFlags &= ~(VIF_MASK | TF_MASK);
535      }
536 }
537
538
539 /**********************************************************************
540  *          DOSVM_GetRMHandler
541  *
542  * Return the real mode interrupt vector for a given interrupt.
543  */
544 FARPROC16 DOSVM_GetRMHandler( BYTE intnum )
545 {
546   return *DOSVM_GetRMVector( intnum );
547 }
548
549
550 /**********************************************************************
551  *          DOSVM_SetRMHandler
552  *
553  * Set the real mode interrupt handler for a given interrupt.
554  */
555 void DOSVM_SetRMHandler( BYTE intnum, FARPROC16 handler )
556 {
557   TRACE("Set real mode interrupt vector %02x <- %04x:%04x\n",
558        intnum, HIWORD(handler), LOWORD(handler) );
559   *DOSVM_GetRMVector( intnum ) = handler;
560 }
561
562
563 /**********************************************************************
564  *          DOSVM_GetPMHandler16
565  *
566  * Return the protected mode interrupt vector for a given interrupt.
567  */
568 FARPROC16 DOSVM_GetPMHandler16( BYTE intnum )
569 {
570     TDB *pTask;
571     FARPROC16 proc = 0;
572
573     pTask = GlobalLock16(GetCurrentTask());
574     if (pTask)
575     {
576         switch( intnum )
577         {
578         case 0x00:
579             proc = pTask->int0;
580             break;
581         case 0x02:
582             proc = pTask->int2;
583             break;
584         case 0x04:
585             proc = pTask->int4;
586             break;
587         case 0x06:
588             proc = pTask->int6;
589             break;
590         case 0x07:
591             proc = pTask->int7;
592             break;
593         case 0x3e:
594             proc = pTask->int3e;
595             break;
596         case 0x75:
597             proc = pTask->int75;
598             break;
599         }
600         if( proc )
601             return proc;
602     }
603     if (!DOSVM_Vectors16[intnum])
604     {
605         proc = (FARPROC16)MAKESEGPTR( DOSVM_dpmi_segments->int16_sel,
606                                                 DOSVM_STUB_PM16 * intnum );
607         DOSVM_Vectors16[intnum] = proc;
608     }
609     return DOSVM_Vectors16[intnum];
610 }
611
612
613 /**********************************************************************
614  *          DOSVM_SetPMHandler16
615  *
616  * Set the protected mode interrupt handler for a given interrupt.
617  */
618 void DOSVM_SetPMHandler16( BYTE intnum, FARPROC16 handler )
619 {
620   TDB *pTask;
621
622   TRACE("Set protected mode interrupt vector %02x <- %04x:%04x\n",
623        intnum, HIWORD(handler), LOWORD(handler) );
624
625   pTask = GlobalLock16(GetCurrentTask());
626   if (!pTask)
627     return;
628   switch( intnum )
629   {
630   case 0x00:
631     pTask->int0 = handler;
632     break;
633   case 0x02:
634     pTask->int2 = handler;
635     break;
636   case 0x04:
637     pTask->int4 = handler;
638     break;
639   case 0x06:
640     pTask->int6 = handler;
641     break;
642   case 0x07:
643     pTask->int7 = handler;
644     break;
645   case 0x3e:
646     pTask->int3e = handler;
647     break;
648   case 0x75:
649     pTask->int75 = handler;
650     break;
651   default:
652     DOSVM_Vectors16[intnum] = handler;
653     break;
654   }
655 }
656
657
658 /**********************************************************************
659  *         DOSVM_GetPMHandler48
660  *
661  * Return the protected mode interrupt vector for a given interrupt.
662  * Used to get 48-bit pointer for 32-bit interrupt handlers in DPMI32.
663  */
664 FARPROC48 DOSVM_GetPMHandler48( BYTE intnum )
665 {
666   if (!DOSVM_Vectors48[intnum].selector)
667   {
668     DOSVM_Vectors48[intnum].selector = DOSVM_dpmi_segments->int48_sel;
669     DOSVM_Vectors48[intnum].offset = DOSVM_STUB_PM48 * intnum;
670   }
671   return DOSVM_Vectors48[intnum];
672 }
673
674
675 /**********************************************************************
676  *         DOSVM_SetPMHandler48
677  *
678  * Set the protected mode interrupt handler for a given interrupt.
679  * Used to set 48-bit pointer for 32-bit interrupt handlers in DPMI32.
680  */
681 void DOSVM_SetPMHandler48( BYTE intnum, FARPROC48 handler )
682 {
683   TRACE("Set 32-bit protected mode interrupt vector %02x <- %04x:%08x\n",
684        intnum, handler.selector, handler.offset );
685   DOSVM_Vectors48[intnum] = handler;
686 }
687
688
689 /**********************************************************************
690  *         DOSVM_CallBuiltinHandler
691  *
692  * Execute Wine interrupt handler procedure.
693  */
694 void WINAPI DOSVM_CallBuiltinHandler( CONTEXT86 *context, BYTE intnum ) 
695 {
696     /*
697      * FIXME: Make all builtin interrupt calls go via this routine.
698      * FIXME: Check for PM->RM interrupt reflection.
699      * FIXME: Check for RM->PM interrupt reflection.
700      */
701
702   INTPROC proc = DOSVM_GetBuiltinHandler( intnum );
703   proc( context );
704 }
705
706
707 /**********************************************************************
708  *          DOSVM_Int11Handler
709  *
710  * Handler for int 11h (get equipment list).
711  *
712  *
713  * Borrowed from Ralph Brown's interrupt lists:
714  *
715  *   bits 15-14: number of parallel devices
716  *   bit     13: [Conv] Internal modem
717  *   bit     12: reserved
718  *   bits 11- 9: number of serial devices
719  *   bit      8: reserved
720  *   bits  7- 6: number of diskette drives minus one
721  *   bits  5- 4: Initial video mode:
722  *                 00b = EGA,VGA,PGA
723  *                 01b = 40 x 25 color
724  *                 10b = 80 x 25 color
725  *                 11b = 80 x 25 mono
726  *   bit      3: reserved
727  *   bit      2: [PS] =1 if pointing device
728  *               [non-PS] reserved
729  *   bit      1: =1 if math co-processor
730  *   bit      0: =1 if diskette available for boot
731  *
732  *
733  * Currently the only of these bits correctly set are:
734  *
735  *   bits 15-14   } Added by William Owen Smith,
736  *   bits 11-9    } wos@dcs.warwick.ac.uk
737  *   bits 7-6
738  *   bit  2       (always set)  ( bit 2 = 4 )
739  *   bit  1       } Robert 'Admiral' Coeyman
740  *                  All *nix systems either have a math processor or
741  *                   emulate one.
742  */
743 static void WINAPI DOSVM_Int11Handler( CONTEXT86 *context )
744 {
745     int diskdrives = 0;
746     int parallelports = 0;
747     int serialports = 0;
748     int x;
749
750     if (GetDriveTypeA("A:\\") == DRIVE_REMOVABLE) diskdrives++;
751     if (GetDriveTypeA("B:\\") == DRIVE_REMOVABLE) diskdrives++;
752     if (diskdrives) diskdrives--;
753
754     for (x=0; x < 9; x++)
755     {
756         HANDLE handle;
757         char file[10];
758
759         /* serial port name */
760         sprintf( file, "\\\\.\\COM%d", x+1 );
761         handle = CreateFileA( file, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
762         if (handle != INVALID_HANDLE_VALUE)
763         {
764             CloseHandle( handle );
765             serialports++;
766         }
767
768         sprintf( file, "\\\\.\\LPT%d", x+1 );
769         handle = CreateFileA( file, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
770         if (handle != INVALID_HANDLE_VALUE)
771         {
772             CloseHandle( handle );
773             parallelports++;
774         }
775     }
776
777     if (serialports > 7) /* 3 bits -- maximum value = 7 */
778         serialports = 7;
779
780     if (parallelports > 3) /* 2 bits -- maximum value = 3 */
781         parallelports = 3;
782
783     SET_AX( context,
784             (diskdrives << 6) | (serialports << 9) | (parallelports << 14) | 0x06 );
785 }
786
787
788 /**********************************************************************
789  *         DOSVM_Int12Handler
790  *
791  * Handler for int 12h (get memory size).
792  */
793 static void WINAPI DOSVM_Int12Handler( CONTEXT86 *context )
794 {
795     SET_AX( context, 640 );
796 }
797
798
799 /**********************************************************************
800  *          DOSVM_Int17Handler
801  *
802  * Handler for int 17h (printer - output character).
803  */
804 static void WINAPI DOSVM_Int17Handler( CONTEXT86 *context )
805 {
806     switch( AH_reg(context) )
807     {
808        case 0x00:/* Send character*/
809             FIXME("Send character not supported yet\n");
810             SET_AH( context, 0x00 );/*Timeout*/
811             break;
812         case 0x01:              /* PRINTER - INITIALIZE */
813             FIXME("Initialize Printer - Not Supported\n");
814             SET_AH( context, 0x30 ); /* selected | out of paper */
815             break;
816         case 0x02:              /* PRINTER - GET STATUS */
817             FIXME("Get Printer Status - Not Supported\n");
818             break;
819         default:
820             SET_AH( context, 0 ); /* time out */
821             INT_BARF( context, 0x17 );
822     }
823 }
824
825
826 /**********************************************************************
827  *          DOSVM_Int19Handler
828  *
829  * Handler for int 19h (Reboot).
830  */
831 static void WINAPI DOSVM_Int19Handler( CONTEXT86 *context )
832 {
833     TRACE( "Attempted Reboot\n" );
834     ExitProcess(0);
835 }
836
837
838 /**********************************************************************
839  *         DOSVM_Int1aHandler
840  *
841  * Handler for int 1ah.
842  */
843 static void WINAPI DOSVM_Int1aHandler( CONTEXT86 *context )
844 {
845     switch(AH_reg(context))
846     {
847     case 0x00: /* GET SYSTEM TIME */
848         {
849             BIOSDATA *data = DOSVM_BiosData();
850             SET_CX( context, HIWORD(data->Ticks) );
851             SET_DX( context, LOWORD(data->Ticks) );
852             SET_AL( context, 0 ); /* FIXME: midnight flag is unsupported */
853             TRACE( "GET SYSTEM TIME - ticks=%d\n", data->Ticks );
854         }
855         break;
856
857     case 0x01: /* SET SYSTEM TIME */
858         FIXME( "SET SYSTEM TIME - not allowed\n" );
859         break;
860
861     case 0x02: /* GET REAL-TIME CLOCK TIME */
862         TRACE( "GET REAL-TIME CLOCK TIME\n" );
863         {
864             SYSTEMTIME systime;
865             GetLocalTime( &systime );
866             SET_CH( context, BIN_TO_BCD(systime.wHour) );
867             SET_CL( context, BIN_TO_BCD(systime.wMinute) );
868             SET_DH( context, BIN_TO_BCD(systime.wSecond) );
869             SET_DL( context, 0 ); /* FIXME: assume no daylight saving */
870             RESET_CFLAG(context);
871         }
872         break;
873
874     case 0x03: /* SET REAL-TIME CLOCK TIME */
875         FIXME( "SET REAL-TIME CLOCK TIME - not allowed\n" );
876         break;
877
878     case 0x04: /* GET REAL-TIME CLOCK DATE */
879         TRACE( "GET REAL-TIME CLOCK DATE\n" );
880         {
881             SYSTEMTIME systime;
882             GetLocalTime( &systime );
883             SET_CH( context, BIN_TO_BCD(systime.wYear / 100) );
884             SET_CL( context, BIN_TO_BCD(systime.wYear % 100) );
885             SET_DH( context, BIN_TO_BCD(systime.wMonth) );
886             SET_DL( context, BIN_TO_BCD(systime.wDay) );
887             RESET_CFLAG(context);
888         }
889         break;
890
891     case 0x05: /* SET REAL-TIME CLOCK DATE */
892         FIXME( "SET REAL-TIME CLOCK DATE - not allowed\n" );
893         break;
894
895     case 0x06: /* SET ALARM */
896         FIXME( "SET ALARM - unimplemented\n" );
897         break;
898
899     case 0x07: /* CANCEL ALARM */
900         FIXME( "CANCEL ALARM - unimplemented\n" );
901         break;
902
903     case 0x08: /* SET RTC ACTIVATED POWER ON MODE */
904     case 0x09: /* READ RTC ALARM TIME AND STATUS */
905     case 0x0a: /* READ SYSTEM-TIMER DAY COUNTER */
906     case 0x0b: /* SET SYSTEM-TIMER DAY COUNTER */
907     case 0x0c: /* SET RTC DATE/TIME ACTIVATED POWER-ON MODE */
908     case 0x0d: /* RESET RTC DATE/TIME ACTIVATED POWER-ON MODE */
909     case 0x0e: /* GET RTC DATE/TIME ALARM AND STATUS */
910     case 0x0f: /* INITIALIZE REAL-TIME CLOCK */
911         INT_BARF( context, 0x1a );
912         break;
913
914     case 0xb0:
915         if (CX_reg(context) == 0x4d52 &&
916             DX_reg(context) == 0x4349 &&
917             AL_reg(context) == 0x01)
918         {
919             /*
920              * Microsoft Real-Time Compression Interface (MRCI).
921              * Ignoring this call indicates MRCI is not supported.
922              */
923             TRACE( "Microsoft Real-Time Compression Interface - not supported\n" );
924         }
925         else
926         {
927             INT_BARF(context, 0x1a);
928         }
929         break;
930
931     default:
932         INT_BARF( context, 0x1a );
933     }
934 }
935
936
937 /**********************************************************************
938  *          DOSVM_Int20Handler
939  *
940  * Handler for int 20h.
941  */
942 static void WINAPI DOSVM_Int20Handler( CONTEXT86 *context )
943 {
944     if (DOSVM_IsWin16())
945         ExitThread( 0 );
946     else if(ISV86(context))
947         MZ_Exit( context, TRUE, 0 );
948     else
949         ERR( "Called from DOS protected mode\n" );
950 }
951
952
953 /**********************************************************************
954  *          DOSVM_Int29Handler
955  *
956  * Handler for int 29h (fast console output)
957  */
958 static void WINAPI DOSVM_Int29Handler( CONTEXT86 *context )
959 {
960    /* Yes, it seems that this is really all this interrupt does. */
961    DOSVM_PutChar(AL_reg(context));
962 }
963
964
965 /**********************************************************************
966  *         DOSVM_Int2aHandler
967  *
968  * Handler for int 2ah (network).
969  */
970 static void WINAPI DOSVM_Int2aHandler( CONTEXT86 *context )
971 {
972     switch(AH_reg(context))
973     {
974     case 0x00:                             /* NETWORK INSTALLATION CHECK */
975         break;
976
977     default:
978        INT_BARF( context, 0x2a );
979     }
980 }
981
982
983 /***********************************************************************
984  *           DOSVM_Int41Handler
985  */
986 static void WINAPI DOSVM_Int41Handler( CONTEXT86 *context )
987 {
988     if ( ISV86(context) )
989     {
990         /* Real-mode debugger services */
991         switch ( AX_reg(context) )
992         {
993         default:
994             INT_BARF( context, 0x41 );
995             break;
996         }
997     }
998     else
999     {
1000         /* Protected-mode debugger services */
1001         switch ( AX_reg(context) )
1002         {
1003         case 0x4f:
1004         case 0x50:
1005         case 0x150:
1006         case 0x51:
1007         case 0x52:
1008         case 0x152:
1009         case 0x59:
1010         case 0x5a:
1011         case 0x5b:
1012         case 0x5c:
1013         case 0x5d:
1014             /* Notifies the debugger of a lot of stuff. We simply ignore it
1015                for now, but some of the info might actually be useful ... */
1016             break;
1017
1018         default:
1019             INT_BARF( context, 0x41 );
1020             break;
1021         }
1022     }
1023 }
1024
1025
1026 /***********************************************************************
1027  *           DOSVM_Int4bHandler
1028  *
1029  */
1030 static void WINAPI DOSVM_Int4bHandler( CONTEXT86 *context )
1031 {
1032     switch(AH_reg(context))
1033     {
1034     case 0x81: /* Virtual DMA Spec (IBM SCSI interface) */
1035         if(AL_reg(context) != 0x02) /* if not install check */
1036         {
1037             SET_CFLAG(context);
1038             SET_AL( context, 0x0f ); /* function is not implemented */
1039         }
1040         break;
1041     default:
1042         INT_BARF(context, 0x4b);
1043     }
1044 }
1045
1046
1047 /***********************************************************************
1048  *           DOSVM_Int5cHandler
1049  *
1050  * Called from NetBIOSCall16.
1051  */
1052 static void WINAPI DOSVM_Int5cHandler( CONTEXT86 *context )
1053 {
1054     BYTE* ptr;
1055     ptr = MapSL( MAKESEGPTR(context->SegEs,BX_reg(context)) );
1056     FIXME("(%p): command code %02x (ignored)\n",context, *ptr);
1057     *(ptr+0x01) = 0xFB; /* NetBIOS emulator not found */
1058     SET_AL( context, 0xFB );
1059 }