414 lines
10 KiB
C
414 lines
10 KiB
C
#include <stdlib.h>
|
|
#include "dos.h"
|
|
#include "go32.h"
|
|
#include <sys/types.h>
|
|
#include "dpmi.h"
|
|
|
|
static union REGS r;
|
|
static struct SREGS s;
|
|
|
|
int _go32_dpmi_allocate_dos_memory(_go32_dpmi_seginfo *info)
|
|
{
|
|
r.x.ax = 0x0100;
|
|
r.x.bx = info->size;
|
|
int86(0x31, &r, &r);
|
|
if (r.x.flags & 1)
|
|
{
|
|
info->size = r.x.bx;
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
info->rm_segment = r.x.ax;
|
|
info->pm_selector = r.x.dx;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_free_dos_memory(_go32_dpmi_seginfo *info)
|
|
{
|
|
r.x.ax = 0x0101;
|
|
r.x.dx = info->pm_selector;
|
|
int86(0x31, &r, &r);
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_resize_dos_memory(_go32_dpmi_seginfo *info)
|
|
{
|
|
r.x.ax = 0x0102;
|
|
r.x.bx = info->size;
|
|
r.x.dx = info->pm_selector;
|
|
int86(0x31, &r, &r);
|
|
if (r.x.flags & 1)
|
|
{
|
|
info->size = r.x.bx;
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_get_real_mode_interrupt_vector(int vector, _go32_dpmi_seginfo *info)
|
|
{
|
|
r.x.ax = 0x0200;
|
|
r.h.bl = vector;
|
|
int86(0x31, &r, &r);
|
|
info->rm_segment = r.x.cx;
|
|
info->rm_offset = r.x.dx;
|
|
return 0;
|
|
}
|
|
|
|
int _go32_dpmi_set_real_mode_interrupt_vector(int vector, _go32_dpmi_seginfo *info)
|
|
{
|
|
r.x.ax = 0x0201;
|
|
r.h.bl = vector;
|
|
r.x.cx = info->rm_segment;
|
|
r.x.dx = info->rm_offset;
|
|
int86(0x31, &r, &r);
|
|
return 0;
|
|
}
|
|
|
|
int _go32_dpmi_get_protected_mode_interrupt_vector(int vector, _go32_dpmi_seginfo *info)
|
|
{
|
|
r.x.ax = 0x0204;
|
|
r.h.bl = vector;
|
|
int86(0x31, &r, &r);
|
|
info->pm_selector = r.x.cx;
|
|
info->pm_offset = r.x.dx;
|
|
return 0;
|
|
}
|
|
|
|
int _go32_dpmi_set_protected_mode_interrupt_vector(int vector, _go32_dpmi_seginfo *info)
|
|
{
|
|
r.x.ax = 0x0205;
|
|
r.h.bl = vector;
|
|
r.x.cx = info->pm_selector;
|
|
r.x.dx = info->pm_offset;
|
|
int86(0x31, &r, &r);
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* In real DPMI, we enter with only CS known, and SS on a locked 4K stack which
|
|
is *NOT* our SS. We must set up everthing, including a stack swap, then
|
|
restore it the way we found it. C. Sandmann 4-93 */
|
|
|
|
static unsigned char wrapper_intcommon[] = {
|
|
0x1e, /* push ds */
|
|
0x06, /* push es */
|
|
0x0f, 0xa0, /* push fs */
|
|
0x0f, 0xa8, /* push gs */
|
|
0x60, /* pusha */
|
|
0x66, 0xb8, 0x34, 0x12, /* mov ax,0x1234 */
|
|
0x8e, 0xd8, /* mov ds,ax */
|
|
0x8e, 0xc0, /* mov es,ax */
|
|
0x8e, 0xe0, /* mov fs,ax */
|
|
0x8e, 0xe8, /* mov gs,ax */
|
|
0xbb, 0x00, 0x00, 0x00, 0x00, /* mov ebx,_local_stack */
|
|
0xfc, /* cld */
|
|
0x89, 0xe1, /* mov ecx,esp */
|
|
0x8c, 0xd2, /* mov dx,ss */
|
|
0x8e, 0xd0, /* mov ss,ax */
|
|
0x89, 0xdc, /* mov esp,ebx */
|
|
0x52, /* push edx */
|
|
0x51, /* push ecx */
|
|
0xe8, 0x00, 0x00, 0x00, 0x00, /* call _rmih */
|
|
0x58, /* pop eax */
|
|
0x5b, /* pop ebx */
|
|
0x8e, 0xd3, /* mov ss,bx */
|
|
0x89, 0xc4, /* mov esp,eax */
|
|
0x61, /* popa */
|
|
0x0f, 0xa9, /* pop gs */
|
|
0x0f, 0xa1, /* pop fs */
|
|
0x07, /* pop es */
|
|
0x1f /* pop ds */
|
|
};
|
|
|
|
static unsigned char wrapper_intiret[] = {
|
|
0xcf /* iret */
|
|
};
|
|
|
|
static unsigned char wrapper_intchain[] = {
|
|
0x2e, 0xff, 0x2d, 0x00, 0x00, 0x00, 0x00, /* jmp cs:[_old_int+39] */
|
|
0xcf, /* iret */
|
|
0x78, 0x56, 0x34, 0x12,
|
|
0xcd, 0xab
|
|
};
|
|
|
|
/* _interrupt_stack_size can be changed globally before calling this routine if
|
|
needed. Don't change it between calls or you will mess up the malloc chain ! */
|
|
|
|
unsigned _interrupt_stack_size = 32256;
|
|
|
|
int _go32_dpmi_chain_protected_mode_interrupt_vector(int vector, _go32_dpmi_seginfo *info)
|
|
{
|
|
char *mystack;
|
|
unsigned char *wrapper = (unsigned char *)malloc(sizeof(wrapper_intcommon) + sizeof(wrapper_intchain));
|
|
if (wrapper == 0)
|
|
return 0x8015;
|
|
mystack = (char *)malloc(_interrupt_stack_size);
|
|
if (mystack == 0)
|
|
return 0x8015;
|
|
|
|
r.x.ax = 0x0204;
|
|
r.h.bl = vector;
|
|
int86(0x31, &r, &r);
|
|
|
|
memcpy(wrapper, wrapper_intcommon, sizeof(wrapper_intcommon));
|
|
memcpy(wrapper+sizeof(wrapper_intcommon), wrapper_intchain, sizeof(wrapper_intchain));
|
|
*(short *)(wrapper+9) = _go32_my_ds();
|
|
*(long *)(wrapper+20) = (int)mystack + _interrupt_stack_size;
|
|
*(long *)(wrapper+36) = info->pm_offset - (int)wrapper - 40;
|
|
*(long *)(wrapper+sizeof(wrapper_intcommon)+3) = (long)wrapper+sizeof(wrapper_intcommon)+8;
|
|
*(long *)(wrapper+sizeof(wrapper_intcommon)+8) = r.x.dx;
|
|
*(short *)(wrapper+sizeof(wrapper_intcommon)+12) = r.x.cx;
|
|
|
|
r.x.ax = 0x0205;
|
|
r.h.bl = vector;
|
|
r.x.cx = _go32_my_cs();
|
|
r.x.dx = (int)wrapper;
|
|
int86(0x31, &r, &r);
|
|
return 0;
|
|
}
|
|
|
|
int _go32_dpmi_allocate_iret_wrapper(_go32_dpmi_seginfo *info)
|
|
{
|
|
char *mystack;
|
|
unsigned char *wrapper = (unsigned char *)malloc(sizeof(wrapper_intcommon) + sizeof(wrapper_intiret));
|
|
if (wrapper == 0)
|
|
return 0x8015;
|
|
mystack = (char *)malloc(_interrupt_stack_size);
|
|
if (mystack == 0)
|
|
return 0x8015;
|
|
|
|
memcpy(wrapper, wrapper_intcommon, sizeof(wrapper_intcommon));
|
|
memcpy(wrapper+sizeof(wrapper_intcommon), wrapper_intiret, sizeof(wrapper_intiret));
|
|
*(short *)(wrapper+9) = _go32_my_ds();
|
|
*(long *)(wrapper+20) = (int)mystack + _interrupt_stack_size;
|
|
*(long *)(wrapper+36) = info->pm_offset - (int)wrapper - 40;
|
|
|
|
info->pm_offset = (int)wrapper;
|
|
return 0;
|
|
}
|
|
|
|
int _go32_dpmi_free_iret_wrapper(_go32_dpmi_seginfo *info)
|
|
{
|
|
char *mystack;
|
|
char *wrapper = (char *)info->pm_offset;
|
|
mystack = (char *)(*(long *)(wrapper+20) - _interrupt_stack_size);
|
|
free(mystack);
|
|
free(wrapper);
|
|
return 0;
|
|
}
|
|
|
|
int _go32_dpmi_simulate_int(int vector, _go32_dpmi_registers *regs)
|
|
{
|
|
r.h.bl = vector;
|
|
r.h.bh = 0;
|
|
r.x.cx = 0;
|
|
r.x.di = (int)regs;
|
|
if (vector == 0x21 && regs->x.ax == 0x4b00)
|
|
{
|
|
r.x.ax = 0xff0a;
|
|
int86(0x21, &r, &r);
|
|
}
|
|
else
|
|
{
|
|
r.x.ax = 0x0300;
|
|
int86(0x31, &r, &r);
|
|
}
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_simulate_fcall(_go32_dpmi_registers *regs)
|
|
{
|
|
r.x.ax = 0x0301;
|
|
r.h.bh = 0;
|
|
r.x.cx = 0;
|
|
r.x.di = (int)regs;
|
|
int86(0x31, &r, &r);
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_simulate_fcall_iret(_go32_dpmi_registers *regs)
|
|
{
|
|
r.x.ax = 0x0302;
|
|
r.h.bh = 0;
|
|
r.x.cx = 0;
|
|
r.x.di = (int)regs;
|
|
int86(0x31, &r, &r);
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Bug here; this needs to be fixed like above with SS & CLD */
|
|
|
|
static unsigned char wrapper_common[] = {
|
|
0x66, 0x06, /* push es */
|
|
0x66, 0x1e, /* push ds */
|
|
0x66, 0x06, /* push es */
|
|
0x66, 0x1f, /* pop ds */
|
|
0x56, /* push esi */
|
|
0x57, /* push edi */
|
|
0xe8, 0x00, 0x00, 0x00, 0x00, /* call _rmcb */
|
|
0x5f, /* pop edi */
|
|
0x5e, /* pop esi */
|
|
0x66, 0x1f, /* pop ds */
|
|
0x66, 0x07, /* pop es */
|
|
0xfc, /* cld */
|
|
0x66, 0x8b, 0x06, /* mov ax,[esi] */
|
|
0x66, 0x26, 0x89, 0x47, 0x2a, /* mov es:[edi+42],ax */
|
|
0x66, 0x8b, 0x46, 0x02, /* mov ax,[esi+2] */
|
|
0x66, 0x26, 0x89, 0x47, 0x2c, /* mov es:[edi+44],ax */
|
|
};
|
|
|
|
static unsigned char wrapper_retf[] = {
|
|
0x66, 0x26, 0x83, 0x47, 0x2e, 0x04, /* add es:[edi+46],0x4 */
|
|
0xcf /* iret */
|
|
};
|
|
|
|
static unsigned char wrapper_iret[] = {
|
|
0x66, 0x8b, 0x46, 0x04, /* mov ax,[esi+4] */
|
|
0x66, 0x26, 0x89, 0x47, 0x20, /* mov es:[edi+32],ax */
|
|
0x66, 0x26, 0x83, 0x47, 0x2e, 0x06, /* add es:[edi+46],0x6 */
|
|
0xcf /* iret */
|
|
};
|
|
|
|
int _go32_dpmi_allocate_real_mode_callback_retf(_go32_dpmi_seginfo *info, _go32_dpmi_registers *regs)
|
|
{
|
|
unsigned char *wrapper = (unsigned char *)malloc(sizeof(wrapper_common) + sizeof(wrapper_retf));
|
|
if (wrapper == 0)
|
|
return 0x8015;
|
|
|
|
memcpy(wrapper, wrapper_common, sizeof(wrapper_common));
|
|
memcpy(wrapper+sizeof(wrapper_common), wrapper_retf, sizeof(wrapper_retf));
|
|
*(long *)(wrapper+11) = info->pm_offset - (int)wrapper - 15;
|
|
info->size = (int)wrapper;
|
|
|
|
r.x.ax = 0x0303;
|
|
r.x.si = (int)wrapper;
|
|
r.x.di = (int)regs;
|
|
s.ds = _go32_my_cs();
|
|
s.es = _go32_my_ds();
|
|
s.fs = 0;
|
|
s.gs = 0;
|
|
int86x(0x31, &r, &r, &s);
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
info->rm_segment = r.x.cx;
|
|
info->rm_offset = r.x.dx;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_allocate_real_mode_callback_iret(_go32_dpmi_seginfo *info, _go32_dpmi_registers *regs)
|
|
{
|
|
unsigned char *wrapper = (unsigned char *)malloc(sizeof(wrapper_common) + sizeof(wrapper_iret));
|
|
if (wrapper == 0)
|
|
return 0x8015;
|
|
|
|
memcpy(wrapper, wrapper_common, sizeof(wrapper_common));
|
|
memcpy(wrapper+sizeof(wrapper_common), wrapper_iret, sizeof(wrapper_iret));
|
|
*(long *)(wrapper+11) = info->pm_offset - (int)wrapper - 15;
|
|
info->size = (int)wrapper;
|
|
|
|
r.x.ax = 0x0303;
|
|
r.x.si = (int)wrapper;
|
|
r.x.di = (int)regs;
|
|
s.ds = _go32_my_cs();
|
|
s.es = _go32_my_ds();
|
|
s.fs = 0;
|
|
s.gs = 0;
|
|
int86x(0x31, &r, &r, &s);
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
info->rm_segment = r.x.cx;
|
|
info->rm_offset = r.x.dx;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_free_real_mode_callback(_go32_dpmi_seginfo *info)
|
|
{
|
|
free((char *)info->size);
|
|
r.x.ax = 0x0304;
|
|
r.x.cx = info->rm_segment;
|
|
r.x.dx = info->rm_offset;
|
|
int86(0x31, &r, &r);
|
|
if (r.x.flags & 1)
|
|
{
|
|
return r.x.ax;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int _go32_dpmi_get_free_memory_information(_go32_dpmi_meminfo *info)
|
|
{
|
|
r.x.ax = 0x0500;
|
|
r.x.di = (int)info;
|
|
int86(0x31, &r, &r);
|
|
return 0;
|
|
}
|
|
|
|
u_long _go32_dpmi_remaining_physical_memory()
|
|
{
|
|
_go32_dpmi_meminfo info;
|
|
_go32_dpmi_get_free_memory_information(&info);
|
|
if (info.available_physical_pages)
|
|
return info.available_physical_pages * 4096;
|
|
return info.available_memory;
|
|
}
|
|
|
|
u_long _go32_dpmi_remaining_virtual_memory()
|
|
{
|
|
_go32_dpmi_meminfo info;
|
|
_go32_dpmi_get_free_memory_information(&info);
|
|
return info.available_memory;
|
|
}
|