?? loader.c
字號(hào):
/*****************************************************************************
* FILE: loader.c *
* *
* DESC: loader for 32bit RSX compiled with EMX/GCC *
* *
* Copyright (C) 1994 *
* Rainer Schnitker, Heeper Str. 283, 33607 Bielefeld *
* email: rainer@mathematik.uni-bielefeld.de *
* *
* See the files "README" and "COPYING" for further copyright and warranty *
* information. *
* *
*****************************************************************************/
#include <dos.h>
#include "LOADER.H"
struct info {
unsigned long membytes;
unsigned long memaddress;
unsigned long text_start;
unsigned long data_start;
unsigned long bss_start;
unsigned long stack_start;
unsigned long init_brk;
unsigned long entry;
unsigned short code16sel;
unsigned short data16sel;
} info;
extern unsigned _psp;
WORD code32sel; /* RSX CS selector */
WORD data32sel; /* RSX DS selector */
DWORD stackp32; /* RSX satck pointer */
static void far *extdata; /* DOS memory for RSX */
static unsigned segm; /* segment address */
static char far * env_str; /* env far pointer */
static char cline[260]; /* arguments */
static int n_strlen(char *str)
{
char *s;
for (s = str; *s; ++s);
return (s - str);
}
static int f_strlen(char far *str)
{
char far *s;
for (s = str; *s; ++s);
return ((int)(char near *)s - (int)(char near *)str);
}
static char *my_strcpy(char *string1, char *string2)
{
char *dst = string1;
while ((*dst = *string2) != 0)
++dst, ++string2;
return (string1);
}
static void error(char *s)
{
dos_puts("loader v1.0 : (c) Rainer Schnitker\n\r$");
dos_puts("rsx_32 loader error: $");
dos_puts(s);
}
static int skip_exe_hdr(int filehandle, DWORD * headoff)
{
struct exe_hdr exehdr;
exehdr.signatur = 0;
dos_read(filehandle, &exehdr, sizeof(WORD) * 3);
if (exehdr.signatur == 0x5a4d) { /* falls exe-kopf */
*headoff += (DWORD) exehdr.high * 512L;
if (exehdr.low)
*headoff += (DWORD) exehdr.low - 512L;
}
if (dos_lseek(filehandle, *headoff, SEEK_SET) != -1L)
return 0;
else {
*headoff = 0;
dos_lseek(filehandle, 0, SEEK_SET);
return -1;
}
}
static int argvenv(int argc, char **argv)
{
DWORD far * vectors; /* building argv, env */
WORD len; /* current len of string */
WORD stkp; /* current stack pos */
WORD count = 3; /* 0=argc 1=argv 2=env */
int i, envc = 0;
static char npx_str[] = "RSX_x87=?";
/* instead allocate memory, take some EMX space at DS:0x8000 */
vectors = (DWORD far *) (((DWORD)segm << 16) | 0x8000);
/* EMX program stack pointer */
/* stack grows down from DS:0xFFFC */
stkp = (WORD) stackp32;
FP_SEG(extdata) = segm;
FP_OFF(extdata) = stkp;
/* store env strings in user stack, built vectors */
for (; *env_str; ) {
len = f_strlen(env_str) + 1;
stkp -= len;
stkp &= ~3;
FP_OFF(extdata) = stkp;
far_memcpy(extdata, env_str, len);
vectors[count++] = (DWORD) stkp;
env_str += len;
envc ++;
}
/* put 387 status on env */
i = npx_installed();
npx_str[8] = (char) i + '0';
len = sizeof(npx_str) + 1;
stkp -= len;
stkp &= ~3;
FP_OFF(extdata) = stkp;
far_memcpy(extdata, (char far *)npx_str, len);
vectors[count++] = (DWORD) stkp;
env_str += len;
envc ++;
vectors[count++] = 0L; /* last is a NULL pointer */
/* store arg strings in user stack, built vectors */
for (i = 0; i < argc; i++) {
len = f_strlen(argv[i]) + 1;
stkp -= len;
stkp &= ~3;
FP_OFF(extdata) = stkp;
far_memcpy(extdata, (void far *) argv[i], len);
vectors[count] = (DWORD) stkp;
count++;
}
vectors[count++] = 0L; /* last is a NULL pointer */
len = count * sizeof(long);
stkp -= len;
vectors[0] = argc;
vectors[1] = stkp + (4 + envc) * sizeof(long); /* & vectors[3+nenvp+1] */
vectors[2] = stkp + 3 * sizeof(long); /* & vectors[3] */
FP_OFF(extdata) = stkp;
far_memcpy(extdata, vectors, len);
stackp32 = stkp; /* save current pos! (for entry) */
stackp32 += 3 * sizeof(long);
return 0;
}
static int read_in(int fhandle, DWORD address, long size)
{
#define READ_MAX 0xFF00
void far *dosmemp;
WORD word_size;
FP_OFF(dosmemp) = 0;
while (size != 0L) {
FP_SEG(dosmemp) = (WORD) (address >> 4);
word_size = (size >> 16) ? READ_MAX : (WORD) size;
dos_read_far(fhandle, dosmemp, word_size);
address += (DWORD) READ_MAX;
size -= (DWORD) word_size;
}
return 0;
}
static int load_protected_program(char *filename)
{
GNUOUT aout_hdr;
DWORD sizetext, sizedata, sizestack;
DWORD headoff;
int fhandle;
if ((fhandle = dos_open(filename, DO_RDONLY | DO_DENYWR)) == -1) {
error("open rsx32 error\r\n$");
return 1;
}
headoff = 0;
skip_exe_hdr(fhandle, &headoff);
/* read gnu aout header */
dos_read(fhandle, &aout_hdr, sizeof(aout_hdr));
/* test header */
if ((WORD) aout_hdr.a_info != 0x10b) {
error("illegal a.out header\r\n$");
dos_close(fhandle);
return 2;
}
sizetext = (aout_hdr.a_text + SEGMENT_SIZE - 1L) & ~(SEGMENT_SIZE - 1L);
sizedata = aout_hdr.a_data + ((aout_hdr.a_bss + 4095L) & ~4095L);
sizestack = 64 * 1024L;
info.text_start = N_TXTADDR(x);
info.data_start = info.text_start + sizetext;
info.bss_start = info.data_start + aout_hdr.a_data;
info.entry = aout_hdr.a_entry;
info.init_brk = info.data_start + sizedata;
stackp32 = info.text_start - 4L;
/* MEMORY per DOS besorgen */
if (!DosReallocParagraph(_psp, (WORD)(info.membytes>>4))) {
error("realloc memory error\r\n$");
return 3;
}
segm = _psp;
info.memaddress = (DWORD)segm << 4;
/* read in code */
dos_lseek(fhandle, headoff + N_TXTOFF(aout_hdr), SEEK_SET);
if (read_in(fhandle, info.memaddress + info.text_start, aout_hdr.a_text))
return 1;
/* read in data */
dos_lseek(fhandle, headoff + N_DATOFF(aout_hdr), SEEK_SET);
if (read_in(fhandle, info.memaddress + info.data_start, aout_hdr.a_data))
return 1;
dos_close(fhandle);
/* zero bss segment */
if (aout_hdr.a_bss) {
FP_SEG(extdata) = (WORD) ((info.memaddress + info.bss_start) >> 4);
FP_OFF(extdata) = (WORD) ((info.memaddress + info.bss_start) & 0xFL);
far_bzero(extdata, (WORD) aout_hdr.a_bss);
}
return 0;
}
static int real_to_protected(WORD mode)
{
static WORD DPMIdata_para_needed;
static WORD DPMIdata_segm_address;
WORD DPMIflags, DPMIversion;
BYTE processor;
DWORD PM_jump; /* switch to protmode jump */
if (GetDpmiEntryPoint(&PM_jump, &DPMIdata_para_needed,
&DPMIflags, &DPMIversion, &processor)) {
error("No DPMI-host found!\r\n$");
return -1;
}
if (mode == 1 && !(DPMIflags & 1)) {
error("32bit programs not supported by Host\r\n$");
return -1;
}
if (DPMIdata_para_needed) { /* get DPMI ring 0 stack */
DPMIdata_segm_address = GetDpmiHostParagraph(DPMIdata_para_needed);
if (!DPMIdata_segm_address) {
error("Can't alloc memory for the DPMI-host-stack\r\n$");
return -1;
}
}
if (DpmiEnterProtectedMode(PM_jump, mode, DPMIdata_segm_address)) {
error("can't switch to Protected Mode\r\n$");
return -1;
}
if (DPMIdata_para_needed)
LockLinRegion((DWORD) DPMIdata_segm_address << 4,
(DWORD) DPMIdata_para_needed << 4);
/* Now we are in Protected Mode */
info.code16sel = GetCS();
info.data16sel = GetDS();
return 0;
}
static void init_descriptors()
{
AllocLDT(2, &(code32sel));
data32sel = code32sel + SelInc();
SetBaseAddress(code32sel, info.memaddress);
SetBaseAddress(data32sel, info.memaddress);
SetAccess(code32sel, APP_CODE_SEL, DEFAULT_BIT | GRANULAR_BIT);
SetAccess(data32sel, APP_DATA_SEL, DEFAULT_BIT | GRANULAR_BIT);
SetLimit(code32sel, info.membytes - 1);
SetLimit(data32sel, info.membytes - 1);
}
static void get_cmdline_from_psp(unsigned psp_segm)
{
int z, env_seg;
char far *cmdl;
/* get envoronment segment from PSP */
env_seg = *(int far *) (((DWORD) psp_segm << 16) | 0x2c);
/* build far pointer to environment */
cmdl = (char far *) ((DWORD) env_seg << 16);
/* save environment pointer */
env_str = (char far *) ((DWORD) env_seg << 16);
/* skip env-strings ; last has two 0-bytes */
for (;;) {
if (*cmdl == '\0' && *(cmdl+1) == '\0')
break;
cmdl++;
}
cmdl += 4;
/* copy arg0 */
for (z = 0; z < sizeof(cline); z++) {
cline[z] = *cmdl;
if (cline[z] == '\0')
break;
cmdl++;
}
cline[z++] = ' ';
/* build cmdline far pointer from PSP */
cmdl = (char far *) ((DWORD) psp_segm << 16 | 0x81);
/* copy arg1,arg2,... */
for ( ; z < sizeof(cline) ; z++) {
cline[z] = *cmdl;
if (cline[z] == 13)
break;
cmdl++;
}
cline[z] = '\0';
}
static void build_args(int *argn, char ***argvp, int stub_opt)
{
static char extra[] = "!RSX";
static char *argvec[20];
int argc, src, dst, bs, quote;
char *q;
argc = 0;
dst = src = 0;
if (stub_opt)
argvec[argc++] = extra;
while (cline[src] == ' ' || cline[src] == '\t' || cline[src] == '\n')
++src;
do {
if (cline[src] == 0)
q = NULL;
else {
q = cline + dst;
bs = 0;
quote = 0;
for (;;) {
if (cline[src] == '"') {
while (bs >= 2) {
cline[dst++] = '\\';
bs -= 2;
}
if (bs & 1)
cline[dst++] = '"';
else
quote = !quote;
bs = 0;
} else if (cline[src] == '\\')
++bs;
else {
while (bs != 0) {
cline[dst++] = '\\';
--bs;
}
if (cline[src] == 0 ||
((cline[src] == ' ' || cline[src] == '\t') && !quote))
break;
cline[dst++] = cline[src];
}
++src;
}
while (cline[src] == ' ' || cline[src] == '\t'
|| cline[src] == '\n')
++src;
cline[dst++] = 0;
}
argvec[argc++] = q;
} while (q != NULL);
*argn = argc - 1;
*argvp = (char **) &(argvec[0]);
}
int main(void)
{
int argc;
char **argv;
char exe_name[130];
get_cmdline_from_psp(_psp);
build_args(&argc, &argv, 0);
my_strcpy(exe_name, argv[0]);
if (argc == 2 && argv[1][0]=='-' && argv[1][1] == '/' && argv[1][6] == '/') {
unsigned newpsp;
int i;
char s;
newpsp = 0;
for ( i=2 ; i<=5 ; i++) {
s = argv[1][i];
if (s >= 'A')
s -= ('A' - 10);
else
s -= '0';
newpsp <<= 4;
newpsp |= s;
}
get_cmdline_from_psp(newpsp);
build_args(&argc, &argv, 1);
}
if (argc > 7 && argv[1][0]=='!' && argv[1][1] == 'p' && argv[1][5] == 'y') {
unsigned newpsp;
int i;
char s;
newpsp = 0;
for ( i=0 ; i<=3 ; i++) {
s = argv[7][i];
if (s >= 'a')
s -= ('a' - 10);
else if (s >= 'A')
s -= ('A' - 10);
else
s -= '0';
newpsp <<= 4;
newpsp |= s;
}
get_cmdline_from_psp(newpsp);
build_args(&argc, &argv, 1);
}
if (load_protected_program(exe_name))
return(1);
if (argvenv(argc, argv))
return (1);
if (real_to_protected(1))
return (1);
init_descriptors();
jmp_to_user();
return 0;
}
?? 快捷鍵說(shuō)明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號(hào)
Ctrl + =
減小字號(hào)
Ctrl + -