/* This is file EXPHDLR.C */
/*
** Copyright (C) 1991 DJ Delorie, 24 Kirsten Ave, Rochester NH 03867-2954
**
** This file is distributed under the terms listed in the document
** "copying.dj", available from DJ Delorie at the address above.
** A copy of "copying.dj" should accompany this file; if not, a copy
** should be available from where this file was obtained. This file
** may not be distributed without a verbatim copy of "copying.dj".
**
** This file is distributed WITHOUT ANY WARRANTY; without even the implied
** warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
/* History:66,55 */
#include <process.h>
#include <stdio.h>
#include <dos.h>
#include <sys/stat.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include "build.h"
#include "types.h"
#include "gdt.h"
#include "idt.h"
#include "tss.h"
#include "utils.h"
#include "paging.h"
#include "npx.h"
#include "mono.h"
#define SEGFAULT(p) { \
printf("Segmentation violation in pointer 0x%08lx\n", (p)); \
return 1; \
}
extern int was_user_int;
char transfer_buffer[4096]; /* must be near ptr for small model */
word32 user_dta;
static struct REGPACK r;
static word32 flmerge(word32 rf, word32 tf)
{
return (rf & 0xcff) | (tf & 0xfffff300L);
}
static set_controller(v)
{
disable();
outportb(0x20, 0x11);
outportb(0x21, v);
outportb(0x21, 4);
outportb(0x21, 1);
enable();
}
init_controllers()
{
movedata(0, 0x08*4, 0, 0x78*4, 0x08*4);
set_controller(0x78);
}
uninit_controllers()
{
set_controller(0x08);
}
extern int ctrl_c_flag;
exception_handler()
{
int i;
#if TOPLINEINFO
char buf[20];
sprintf(buf, "0x%08lx", tss_ptr->tss_eip);
for (i=0; buf[i]; i++)
poke(screen_seg, i*2+80, buf[i] | 0x0600);
#endif
i = tss_ptr->tss_irqn;
/* printf("i=%#02x, a0=%02x\n", i, inportb(0xa0)); */
if ((i>=0x70) && (i<0x7f) && (i != 0x75))
{
if (i<0x78)
intr(i, &r);
else
intr(i-0x70, &r);
if (i == 0x79)
{
r.r_ax = 0x0100;
intr(0x16, &r);
if (!(r.r_flags & 0x40) && (r.r_ax == 0x2e03))
{
_AH = 0;
geninterrupt(0x16);
ctrl_c_flag = 1;
}
}
if (ctrl_c_flag)
{
ctrl_c_flag = 0;
return 1;
}
return 0;
}
switch (i)
{
case 8:
printf("double fault!\n");
exit(1);
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 9:
case 10:
case 11:
case 12:
case 13:
case 15:
return 1;
case 0x75:
return 1;
case 7:
printf("Fatal! Application attempted to use not-present 80387!\n");
printf("Floating point opcode at virtual address 0x%08lx\n", tss_ptr->tss_eip);
return 1;
case 14:
return page_in();
case 0x10:
return i_10();
case 0x11:
case 0x12:
case 0x14:
case 0x16:
case 0x17:
case 0x1a:
return generic_handler();
case 0x21:
return i_21();
case 0x33:
return i_33();
default:
return 1;
}
}
#if DEBUGGER
static char flset[] = "VMRF NT OFDNIETFMIZR AC PE CY";
static char floff[] = " UPID PLNZ PO NC";
static char fluse[] = {1,1,0,1,0,0,1,1,1,1,1,1,0,1,0,1,0,1};
tssprint(TSS *t)
{
int i;
printf("eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx\n",
t->tss_eax, t->tss_ebx, t->tss_ecx, t->tss_edx);
printf("esi=%08lx edi=%08lx ebp=%08lx ",
t->tss_esi, t->tss_edi, t->tss_ebp);
for (i=0; i<18; i++)
if (fluse[i])
if (t->tss_eflags & (1<<(17-i)))
printf(" %2.2s", flset+i*2);
else
printf(" %2.2s", floff+i*2);
printf("\nds=%04x es=%04x fs=%04x gs=%04x ss:esp=%04x:%08lx cs=%04x\n",
t->tss_ds, t->tss_es, t->tss_fs, t->tss_gs, t->tss_ss, t->tss_esp, t->tss_cs);
}
#endif /* DEBUGGER */
int retrieve_string(word32 v, char *transfer_buffer, char tchar)
{
int i;
char c;
for (i=0; i<4096; i++)
{
c = peek8(v);
v++;
transfer_buffer[i] = c;
if (c == tchar)
break;
}
return i+1; /* number of characters placed in buffer */
}
static int old_text_mode = -1;
generic_handler()
{
tss2reg(&r);
intr(tss_ptr->tss_irqn, &r);
reg2tss(&r);
return 0;
}
i_10()
{
if ((tss_ptr->tss_eax & 0xFF00) == 0xFF00)
{
graphics_mode(tss_ptr->tss_eax & 0xff);
return 0;
}
tss2reg(&r);
intr(0x10, &r);
reg2tss(&r);
tss_ptr->tss_ebp = r.r_es * 16L + r.r_bp + 0xe0000000L;
return 0;
}
i_33()
{
if (*((unsigned far *)0x000000CEL) == 0)
return 0;
r.r_ax = tss_ptr->tss_eax;
r.r_bx = tss_ptr->tss_ebx;
r.r_cx = tss_ptr->tss_ecx;
r.r_dx = tss_ptr->tss_edx;
intr(0x33, &r);
tss_ptr->tss_eax = r.r_ax;
tss_ptr->tss_ebx = r.r_bx;
tss_ptr->tss_ecx = r.r_cx;
tss_ptr->tss_edx = r.r_dx;
return 0;
}
TSS last_tss;
i_21()
{
word32 v, trans_total, countleft;
int i, c, ah, tchar, trans_count;
char *cp;
memcpy(&last_tss, tss_ptr, sizeof(TSS));
tss2reg(&r);
ah = (tss_ptr->tss_eax >> 8) & 0xff;
#if 0
printf("int 21h ax=0x%04x bx=0x%04x cx=0x%04x dx=0x%04x\n",
(int)(tss_ptr->tss_eax),
(int)(tss_ptr->tss_ebx),
(int)(tss_ptr->tss_ecx),
(int)(tss_ptr->tss_edx)
);
#endif
switch (ah)
{
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 0x0b:
case 0x2a:
case 0x2b:
case 0x2c:
case 0x2d:
case 0x33:
case 0x42:
case 0x45:
case 0x46:
case 0x57:
case 0x68:
intr(0x21, &r);
reg2tss(&r);
return 0;
case 0x3e:
#if DEBUGGER
if (r.r_bx <= 2)
return 0;
#endif
intr(0x21, &r);
reg2tss(&r);
return 0;
case 9:
case 0x39:
case 0x3a:
case 0x3b:
case 0x41:
case 0x43:
if (ah == 9)
tchar = '$';
else
tchar = 0;
v = tss_ptr->tss_edx + ARENA;
if (!page_is_valid(v))
{
printf("Segmentation violation in pointer 0x%08lx\n", tss_ptr->tss_edx);
return 1;
}
retrieve_string(v, transfer_buffer, tchar);
r.r_dx = FP_OFF(transfer_buffer);
r.r_ds = _DS;
intr(0x21, &r);
reg2tss(&r);
return 0;
case 0x3c:
v = tss_ptr->tss_edx + ARENA;
if (!page_is_valid(v))
{
printf("Segmentation violation in pointer 0x%08lx\n", tss_ptr->tss_edx);
return 1;
}
retrieve_string(v, transfer_buffer, 0);
i = _creat(transfer_buffer, (int)(tss_ptr->tss_ecx));
if (i < 0)
{
tss_ptr->tss_eax = errno;
tss_ptr->tss_eflags |= 1;
}
else
{
tss_ptr->tss_eax = i;
tss_ptr->tss_eflags &= ~1;
}
return 0;
case 0x3d:
v = tss_ptr->tss_edx + ARENA;
if (!page_is_valid(v))
{
printf("Segmentation violation in pointer 0x%08lx\n", tss_ptr->tss_edx);
return 1;
}
retrieve_string(v, transfer_buffer, 0);
i = tss_ptr->tss_eax & 0xf0;
if (tss_ptr->tss_eax & O_WRONLY) i &= 1;
if (tss_ptr->tss_eax & O_RDWR) i &= 2;
i = _open(transfer_buffer, i);
if (i < 0)
{
tss_ptr->tss_eax = errno;
tss_ptr->tss_eflags |= 1;
}
else
{
tss_ptr->tss_eax = i;
tss_ptr->tss_eflags &= ~1;
}
return 0;
case 0x1a:
user_dta = tss_ptr->tss_edx;
setdta((char far *)transfer_buffer);
return 0;
case 0x2f:
tss_ptr->tss_ebx = user_dta;
return 0;
case 0x30:
intr(0x21, &r);
reg2tss(&r);
return 0;
case 0x56:
v = tss_ptr->tss_edx + ARENA;
if (!page_is_valid(v))
{
printf("Segmentation violation in pointer 0x%08lx\n", tss_ptr->tss_edx);
return 1;
}
i = retrieve_string(v, transfer_buffer, 0);
r.r_dx = FP_OFF(transfer_buffer);
r.r_ds = _DS;
v = tss_ptr->tss_edi + ARENA;
retrieve_string(v, transfer_buffer+i, 0);
r.r_di = FP_OFF(transfer_buffer)+i;
r.r_es = _DS;
intr(0x21, &r);
tss_ptr->tss_eax = r.r_ax;
tss_ptr->tss_eflags = flmerge(r.r_flags, tss_ptr->tss_eflags);
return 0;
case 0x3f:
trans_total = 0;
countleft = tss_ptr->tss_ecx;
v = tss_ptr->tss_edx;
if (!page_is_valid(v+ARENA))
{
printf("Segmentation violation in pointer 0x%08lx\n", tss_ptr->tss_edx);
return 1;
}
while (countleft > 0)
{
trans_count = (countleft <= 4096) ? countleft : 4096;
i = read(r.r_bx, transfer_buffer, trans_count);
if (i < 0)
{
tss_ptr->tss_eflags |= 1; /* carry */
tss_ptr->tss_eax = _doserrno;
return 0;
}
memput(v+ARENA, transfer_buffer, i);
trans_total += i;
v += i;
countleft -= i;
if (isatty(r.r_bx) && (i<trans_count))
break; /* they're line buffered */
if (i == 0)
break;
}
tss_ptr->tss_eax = trans_total;
tss_ptr->tss_eflags &= ~1;
return 0;
case 0x40:
trans_total = 0;
countleft = tss_ptr->tss_ecx;
if (countleft == 0)
{
r.r_ax = 0x4000;
r.r_cx = 0;
intr(0x21,&r);
tss_ptr->tss_eax = 0;
tss_ptr->tss_eflags &= ~1;
return 0;
}
v = tss_ptr->tss_edx;
if (!page_is_valid(v+ARENA))
SEGFAULT(v);
r.r_dx = (int)transfer_buffer;
while (countleft > 0)
{
trans_count = (countleft <= 4096) ? countleft : 4096;
memget(v+ARENA, transfer_buffer, trans_count);
i = write(r.r_bx, transfer_buffer, trans_count);
if (i<0) /* carry */
{
tss_ptr->tss_eflags |= 1; /* carry */
tss_ptr->tss_eax = _doserrno;
return 0;
}
trans_total += i;
v += i;
countleft -= i;
if (i < trans_count)
break;
}
tss_ptr->tss_eax = trans_total;
tss_ptr->tss_eflags &= ~1;
return 0;
case 0x44:
return i_21_44();
case 0x4e:
if (!page_is_valid(user_dta+ARENA))
SEGFAULT(user_dta);
v = tss_ptr->tss_edx + ARENA;
if (!page_is_valid(v))
SEGFAULT(v);
retrieve_string(v, transfer_buffer+43, 0);
r.r_dx = FP_OFF(transfer_buffer+43);
r.r_ds = _DS;
intr(0x21, &r);
reg2tss(&r);
for (i=20; i>=0; i--)
transfer_buffer[i+28] = transfer_buffer[i+26];
transfer_buffer[32+13] = 0; /* asciiz termination */
memput(user_dta+ARENA, transfer_buffer, 48);
return 0;
case 0x4f:
if (!page_is_valid(user_dta+ARENA))
SEGFAULT(user_dta);
memget(user_dta+ARENA, transfer_buffer, 48);
for (i=0; i<=20; i++)
transfer_buffer[i+26] = transfer_buffer[i+28];
intr(0x21, &r);
reg2tss(&r);
for (i=20; i>=0; i--)
transfer_buffer[i+28] = transfer_buffer[i+26];
transfer_buffer[32+13] = 0; /* asciiz termination */
memput(user_dta+ARENA, transfer_buffer, 48);
return 0;
case 0x47:
getcurdir((int)(tss_ptr->tss_edx & 0xff), transfer_buffer);
for (cp=transfer_buffer; *cp; cp++)
{
if (*cp == '\\') *cp = '/';
*cp = tolower(*cp);
}
memput(tss_ptr->tss_esi+ARENA, transfer_buffer, strlen(transfer_buffer));
tss_ptr->tss_eax = (unsigned)r.r_ax;
tss_ptr->tss_eflags &= ~1;
return 0;
case 0x4a:
if (tss_ptr->tss_eax & 0xff)
tss_ptr->tss_eax = paging_sbrk(tss_ptr->tss_ebx);
else
tss_ptr->tss_eax = paging_brk(tss_ptr->tss_ebx);
return 0;
case 0x4c:
#if DEBUGGER
printf("Program exited normally, return code %d (0x%x)\n",
(int)(tss_ptr->tss_eax & 0xff), (int)(tss_ptr->tss_eax & 0xff));
return 1;
#else
exit(tss_ptr->tss_eax & 0xff);
#endif
case 0xff:
return turbo_assist();
default:
return 1;
}
}
struct time32 {
word32 secs;
word32 usecs;
};
struct tz32 {
word32 offset;
word32 dst;
};
struct stat32 {
short st_dev;
short st_ino;
short st_mode;
short st_nlink;
short st_uid;
short st_gid;
short st_rdev;
short st_align_for_word32;
long st_size;
long st_atime;
long st_mtime;
long st_ctime;
long st_blksize;
};
static int dev_count=1;
turbo_assist()
{
word32 p1, p2, p3, r;
struct time32 time32;
struct tz32 tz32;
struct stat32 statbuf32;
struct stat statbuf;
int i;
char buf[128];
p1 = tss_ptr->tss_ebx;
p2 = tss_ptr->tss_ecx;
p3 = tss_ptr->tss_edx;
switch (tss_ptr->tss_eax & 0xff)
{
case 1:
retrieve_string(p1+ARENA, buf, 0);
r = creat(buf, S_IREAD | S_IWRITE);
break;
case 2:
retrieve_string(p1+ARENA, buf, 0);
r = open(buf, (int)p2, S_IREAD | S_IWRITE);
break;
case 3:
memset(&statbuf, 0, sizeof(statbuf));
r = fstat((int)p1, &statbuf);
statbuf32.st_dev = dev_count++;
statbuf32.st_ino = statbuf.st_ino;
statbuf32.st_mode = statbuf.st_mode;
statbuf32.st_nlink = statbuf.st_nlink;
statbuf32.st_uid = statbuf.st_uid;
statbuf32.st_gid = statbuf.st_gid;
statbuf32.st_rdev = statbuf.st_rdev;
statbuf32.st_size = statbuf.st_size;
statbuf32.st_atime = statbuf.st_atime;
statbuf32.st_mtime = statbuf.st_mtime;
statbuf32.st_ctime = statbuf.st_ctime;
statbuf32.st_blksize = 512;
memput(p2+ARENA, &statbuf32, sizeof(statbuf32));
break;
case 4:
if (p2)
{
if (!page_is_valid(p2+ARENA))
SEGFAULT(p2);
tz32.offset = timezone;
tz32.dst = daylight;
memput(p2+ARENA, &tz32, sizeof(tz32));
}
if (p1)
{
if (!page_is_valid(p1+ARENA))
SEGFAULT(p1);
time(&(time32.secs));
_AH = 0x2c;
geninterrupt(0x21);
time32.usecs = _DL * 10000L;
memput(p1+ARENA, &time32, sizeof(time32));
}
r = 0;
break;
case 5:
if (p2)
{
if (!page_is_valid(p2+ARENA))
SEGFAULT(p2);
memget(p2+ARENA, &tz32, sizeof(tz32));
timezone = tz32.offset;
daylight = tz32.dst;
}
if (p1)
{
if (!page_is_valid(p1+ARENA))
SEGFAULT(p1);
memget(p1+ARENA, &time32, sizeof(time32));
stime(&(time32.secs));
}
r = 0;
break;
case 6:
memset(&statbuf, 0, sizeof(statbuf));
retrieve_string(p1+ARENA, transfer_buffer, 0);
r = stat(transfer_buffer, &statbuf);
statbuf32.st_dev = dev_count++;
statbuf32.st_ino = statbuf.st_ino;
statbuf32.st_mode = statbuf.st_mode;
statbuf32.st_nlink = statbuf.st_nlink;
statbuf32.st_uid = statbuf.st_uid;
statbuf32.st_gid = statbuf.st_gid;
statbuf32.st_rdev = statbuf.st_rdev;
statbuf32.st_size = statbuf.st_size;
statbuf32.st_atime = statbuf.st_atime;
statbuf32.st_mtime = statbuf.st_mtime;
statbuf32.st_ctime = statbuf.st_ctime;
statbuf32.st_blksize = 512;
memput(p2+ARENA, &statbuf32, sizeof(statbuf32));
break;
case 7:
retrieve_string(p1+ARENA, transfer_buffer, 0);
page_out_everything();
uninit_controllers();
sscanf(transfer_buffer, "%s%n", buf, &i);
if (strpbrk(transfer_buffer, "<>|") == NULL)
r = spawnlp(P_WAIT, buf, buf, transfer_buffer+i, 0);
else
r = -1;
if (r & 0x80000000L)
r = system(transfer_buffer);
init_controllers();
page_in_everything();
break;
case 8:
r = setmode((int)p1, (int)p2);
break;
default:
return 1;
}
tss_ptr->tss_eflags &= ~1;
if (r == -1)
{
tss_ptr->tss_eflags |= 1;
tss_ptr->tss_eax = errno;
return 0;
}
tss_ptr->tss_eax = r;
return 0;
}
i_21_44()
{
switch (tss_ptr->tss_eax & 0xff)
{
case 0x00:
case 0x01:
case 0x06:
case 0x07:
intr(0x21, &r);
tss_ptr->tss_edx = r.r_dx;
tss_ptr->tss_eax = r.r_ax;
tss_ptr->tss_eflags = flmerge(r.r_flags, tss_ptr->tss_eflags);
return 0;
default:
return 1;
}
}
tss2reg(struct REGPACK *r)
{
r->r_ax = tss_ptr->tss_eax;
r->r_bx = tss_ptr->tss_ebx;
r->r_cx = tss_ptr->tss_ecx;
r->r_dx = tss_ptr->tss_edx;
r->r_si = tss_ptr->tss_esi;
r->r_di = tss_ptr->tss_edi;
r->r_flags = tss_ptr->tss_eflags;
r->r_ds = r->r_es = _DS;
}
reg2tss(struct REGPACK *r)
{
tss_ptr->tss_eax = r->r_ax;
tss_ptr->tss_ebx = r->r_bx;
tss_ptr->tss_ecx = r->r_cx;
tss_ptr->tss_edx = r->r_dx;
tss_ptr->tss_esi = r->r_si;
tss_ptr->tss_edi = r->r_di;
tss_ptr->tss_eflags = flmerge(r->r_flags, tss_ptr->tss_eflags);
}
