int palette_load(const char *file_name, palette_t *palette_return)
{
palette_t *tmp_palette;
char *complete_path;
FILE *f;
int rc;
f = sysfile_open(file_name, &complete_path, MODE_READ_TEXT);
if (f == NULL) {
/* Try to add the extension. */
char *tmp = lib_stralloc(file_name);
util_add_extension(&tmp, "vpl");
f = sysfile_open(tmp, &complete_path, MODE_READ_TEXT);
lib_free(tmp);
if (f == NULL)
return -1;
}
log_message(palette_log, "Loading palette `%s'.", complete_path);
lib_free(complete_path);
tmp_palette = palette_create(palette_return->num_entries, NULL);
rc = palette_load_core(f, file_name, tmp_palette, palette_return);
fclose(f);
palette_free(tmp_palette);
return rc;
}
// user_main - kernel thread used to exec a user program
static int user_main(void *arg)
{
sysfile_open("stdin:", O_RDONLY);
sysfile_open("stdout:", O_WRONLY);
sysfile_open("stdout:", O_WRONLY);
#ifdef UNITTEST
#ifdef TESTSCRIPT
KERNEL_EXECVE3(UNITTEST, TESTSCRIPT);
#else
KERNEL_EXECVE2(UNITTEST);
#endif
#else
__KERNEL_EXECVE("/bin/sh", "/bin/sh");
#endif
kprintf("user_main execve failed, no /bin/sh?.\n");
}
int sdlkbd_hotkeys_load(const char *filename)
{
FILE *fp;
char *complete_path = NULL;
char buffer[1000];
/* Silently ignore keymap load on resource & cmdline init */
if (sdlkbd_log == LOG_ERR) {
return 0;
}
if (filename == NULL) {
log_warning(sdlkbd_log, "Failed to open NULL.");
return -1;
}
fp = sysfile_open(filename, &complete_path, MODE_READ_TEXT);
if (fp == NULL) {
log_warning(sdlkbd_log, "Failed to open `%s'.", filename);
return -1;
}
log_message(sdlkbd_log, "Loading hotkey map `%s'.", complete_path);
lib_free(complete_path);
do {
buffer[0] = 0;
if (fgets(buffer, 999, fp)) {
char *p;
if (strlen(buffer) == 0) {
break;
}
buffer[strlen(buffer) - 1] = 0; /* remove newline */
/* remove comments */
if ((p = strchr(buffer, '#'))) {
*p = 0;
}
switch (*buffer) {
case 0:
break;
case '!':
/* keyword handling */
sdlkbd_parse_keyword(buffer);
break;
default:
/* table entry handling */
sdlkbd_parse_entry(buffer);
break;
}
}
} while (!feof(fp));
fclose(fp);
return 0;
}
static uint32_t
sys_open(uint32_t arg[]) {
const char *path = (const char *)arg[0];
uint32_t open_flags = (uint32_t)arg[1];
kprintf("path:%s\n", path);
return sysfile_open(path, open_flags);
}
/* As `sysfile_open', but do not open the file. Just return 0 if the file is
found and is readable, or -1 if an error occurs. */
int sysfile_locate(const char *name, char **complete_path_return)
{
FILE *f = sysfile_open(name, complete_path_return, MODE_READ);
if (f != NULL) {
fclose(f);
return 0;
} else {
return -1;
}
}
int romset_file_load(const char *filename)
{
FILE *fp;
int retval, line_num;
int err = 0;
char *complete_path, *dir;
const char *saved_path;
if (filename == NULL) {
log_error(romset_log, "ROM set filename is NULL!");
return -1;
}
fp = sysfile_open(filename, &complete_path, MODE_READ_TEXT);
if (fp == NULL) {
log_warning(romset_log, "Could not open file '%s' for reading (%s)!",
filename, strerror(errno));
return -1;
}
log_message(romset_log, "Loading ROM set from file '%s'", filename);
/* Prepend dir to search path */
util_fname_split(complete_path, &dir, NULL);
saved_path = prepend_dir_to_path(dir);
lib_free(dir);
lib_free(complete_path);
line_num = 0;
do {
retval = resources_read_item_from_file(fp);
switch (retval) {
case RESERR_TYPE_INVALID:
log_error(romset_log,
"%s: Invalid resource specification at line %d.",
filename, line_num);
err = 1;
break;
case RESERR_UNKNOWN_RESOURCE:
log_warning(romset_log,
"%s: Unknown resource specification at line %d.",
filename, line_num);
break;
}
line_num++;
} while (retval != 0);
/* Restore search path */
restore_path(saved_path);
fclose(fp);
return err;
}
int romset_file_load(const char *filename)
{
FILE *fp;
int retval, line_num;
int err = 0;
if (filename == NULL) {
log_error(romset_log, "ROM set filename is NULL!");
return -1;
}
fp = sysfile_open(filename, NULL, MODE_READ_TEXT);
if (fp == NULL) {
log_warning(romset_log, "Could not open file '%s' for reading (%s)!",
filename, strerror(errno));
return -1;
}
log_message(romset_log, "Loading ROM set from file '%s'", filename);
line_num = 0;
do {
retval = resources_read_item_from_file(fp);
if (retval == -1) {
log_error(romset_log,
"%s: Invalid resource specification at line %d.",
filename, line_num);
err = 1;
} else {
if (retval == -2) {
log_warning(romset_log,
"%s: Unknown resource specification at line %d.",
filename, line_num);
}
}
line_num++;
} while (retval != 0);
fclose(fp);
return err;
}
static bool checkCrc32(const unsigned id)
{
int bytesRead;
U8 tempBuffer[1024];
U32 expectedCrc32, calculatedCrc32 = MZ_CRC32_INIT;
file_t fp = sysfile_open(resourceFiles[id]);
if (fp == NULL)
{
sys_error("(resources) unable to open \"%s\"", resourceFiles[id]);
return false;
}
bytesRead = sysfile_read(fp, tempBuffer, sizeof(U32), 1); /* prepare beginning of buffer for the following loop */
if (bytesRead != 1)
{
sys_error("(resources) not enough data for \"%s\"", resourceFiles[id]);
sysfile_close(fp);
return false;
}
do
{
bytesRead = sysfile_read(fp, tempBuffer + sizeof(U32), sizeof(U8), sizeof(tempBuffer) - sizeof(U32));
calculatedCrc32 = mz_crc32(calculatedCrc32, tempBuffer, bytesRead);
memcpy(tempBuffer, tempBuffer + bytesRead, sizeof(U32));
} while (bytesRead == sizeof(tempBuffer) - sizeof(U32));
sysfile_close(fp);
memcpy(&expectedCrc32, tempBuffer, sizeof(U32));
expectedCrc32 = letoh32(expectedCrc32);
if (expectedCrc32 != calculatedCrc32)
{
sys_error("(resources) crc check failed for \"%s\"", resourceFiles[id]);
return false;
}
return true;
}
int load_keymap_file(const char *fname)
{
FILE *fp;
int num = 0;
char *complete_path;
if (fname == NULL)
return -1;
fp = sysfile_open(fname, &complete_path, "r");
if (fp == NULL) {
char *tmp = util_concat(fname, ".vkm", NULL);
fp = sysfile_open(tmp, &complete_path, "r");
lib_free(tmp);
}
if (fp == NULL)
return -1;
else
log_message(LOG_DEFAULT, "Loading keymap `%s'.", complete_path);
lib_free(complete_path);
while (!feof(fp))
{
char buffer[81];
if (util_get_line(buffer, 80, fp))
switch (buffer[0])
{
case 0:
case '/':
break;
case '#':
case 'S':
case 'U':
// table entry handling
{
// FIXME: ERROR LOGGING MISSING
char *p;
char *dummy;
unsigned long code1, code2;
int row, col, shift;
if (keyconvmap.symbolic == 1)
{
p = strtok(buffer+1, " \t,");
if (!p)
break;
code1 = strtoul(p, &dummy, 10);
if (code1>0xff)
break;
p = strtok(NULL, " \t:");
if (!p)
break;
code2 = strtoul(p, &dummy, 10);
if (code2>0xff)
break;
}
else
{
p = strtok(buffer+1, " \t:");
if (!p)
break;
code1 = strtoul(p, &dummy, 10);
if (code1>0xff)
break;
code2 = 0;
}
p = strtok(NULL, " \t,");
if (!p)
break;
row = atoi(p);
p = strtok(NULL, " \t,");
if (!p)
break;
col = atoi(p);
p = strtok(NULL, " \t");
if (!(p || row < 0))
break;
if (p)
shift = atoi(p);
{
switch (buffer[0])
{
case '#':
keyconvmap.map[0][num].code = code1 | code2<<8;
keyconvmap.map[0][num].row = row;
keyconvmap.map[0][num].column = col;
keyconvmap.map[0][num].vshift = shift;
keyconvmap.map[1][num].code = code1 | code2<<8;
keyconvmap.map[1][num].row = row;
keyconvmap.map[1][num].column = col;
keyconvmap.map[1][num].vshift = shift;
num++;
break;
case 'S':
keyconvmap.map[1][num].code = code1 | code2<<8;
keyconvmap.map[1][num].row = row;
keyconvmap.map[1][num].column = col;
keyconvmap.map[1][num].vshift = shift;
num++;
break;
case 'U':
keyconvmap.map[0][num].code = code1 | code2<<8;
keyconvmap.map[0][num].row = row;
keyconvmap.map[0][num].column = col;
keyconvmap.map[0][num].vshift = shift;
num++;
break;
}
// log_debug("setting %i (%i) to r%i c%i = %i s%i", num, s, row, col, code1|code2<<8, shift);
}
}
case '!': // keyword handling
{
char *p;
int row, col;
p = strtok(buffer+1, " \t:");
if (!p)
break;
if (!strcmp(p, "LSHIFT"))
{
p = strtok(NULL, " \t,");
if (!p)
break;
row = atoi(p);
p = strtok(NULL, " \t,");
if (!p)
break;
col = atoi(p);
keyconvmap.lshift_row = row;
keyconvmap.lshift_col = col;
}
if (!strcmp(p, "RSHIFT"))
{
p = strtok(NULL, " \t,");
if (!p)
break;
row = atoi(p);
p = strtok(NULL, " \t,");
if (!p)
break;
col = atoi(p);
keyconvmap.rshift_row = row;
keyconvmap.rshift_col = col;
}
if (!strcmp(p, "KSCODE"))
keyconvmap.symbolic = 0; // FALSE
if (!strcmp(p, "KSYM"))
keyconvmap.symbolic = 1; // TRUE
}
break;
default:
break;
}
if (num==0x100)
{
log_message(LOG_DEFAULT, "parse.c: Warning: keyboard file contains more than 255 entries.");
break;
}
}
keyconvmap.entries = num;
fclose(fp);
return 0;
}
static int sys_open(uint32_t arg[])
{
const char *path = (const char *)arg[0];
uint32_t open_flags = (uint32_t) arg[1];
return sysfile_open(path, open_flags);
}
}
unlock_mm(mm);
kfree(kls);
return ret;
}
int sysfile_linux_fcntl64(int fd, int cmd, int arg)
{
kprintf("sysfile_linux_fcntl64:fd=%08x cmd=%08x arg=%08x\n", fd, cmd,
arg);
return 0;
}
int sysfile_linux_stat(const char __user * fn, struct linux_stat *__user buf)
{
int fd = sysfile_open(fn, O_RDONLY);
if (fd < 0)
return -1;
int ret = sysfile_linux_fstat(fd, buf);
sysfile_close(fd);
return ret;
}
int
sysfile_linux_stat64(const char __user * fn, struct linux_stat64 *__user buf)
{
int fd = sysfile_open(fn, O_RDONLY);
if (fd < 0)
return -1;
int ret = sysfile_linux_fstat64(fd, buf);
static int load_icode(int fd, int argc, char **kargv, int envc, char **kenvp)
{
assert(argc >= 0 && argc <= EXEC_MAX_ARG_NUM);
assert(envc >= 0 && envc <= EXEC_MAX_ENV_NUM);
if (current->mm != NULL) {
panic("load_icode: current->mm must be empty.\n");
}
int ret = -E_NO_MEM;
//#ifdef UCONFIG_BIONIC_LIBC
uint32_t real_entry;
//#endif //UCONFIG_BIONIC_LIBC
struct mm_struct *mm;
if ((mm = mm_create()) == NULL) {
goto bad_mm;
}
if (setup_pgdir(mm) != 0) {
goto bad_pgdir_cleanup_mm;
}
mm->brk_start = 0;
struct Page *page;
struct elfhdr __elf, *elf = &__elf;
if ((ret = load_icode_read(fd, elf, sizeof(struct elfhdr), 0)) != 0) {
goto bad_elf_cleanup_pgdir;
}
if (elf->e_magic != ELF_MAGIC) {
ret = -E_INVAL_ELF;
goto bad_elf_cleanup_pgdir;
}
//#ifdef UCONFIG_BIONIC_LIBC
real_entry = elf->e_entry;
uint32_t load_address, load_address_flag = 0;
//#endif //UCONFIG_BIONIC_LIBC
struct proghdr __ph, *ph = &__ph;
uint32_t vm_flags, phnum;
pte_perm_t perm = 0;
//#ifdef UCONFIG_BIONIC_LIBC
uint32_t is_dynamic = 0, interp_idx;
uint32_t bias = 0;
//#endif //UCONFIG_BIONIC_LIBC
for (phnum = 0; phnum < elf->e_phnum; phnum++) {
off_t phoff = elf->e_phoff + sizeof(struct proghdr) * phnum;
if ((ret =
load_icode_read(fd, ph, sizeof(struct proghdr),
phoff)) != 0) {
goto bad_cleanup_mmap;
}
if (ph->p_type == ELF_PT_INTERP) {
is_dynamic = 1;
interp_idx = phnum;
continue;
}
if (ph->p_type != ELF_PT_LOAD) {
continue;
}
if (ph->p_filesz > ph->p_memsz) {
ret = -E_INVAL_ELF;
goto bad_cleanup_mmap;
}
if (ph->p_va == 0 && !bias) {
bias = 0x00008000;
}
if ((ret = map_ph(fd, ph, mm, &bias, 0)) != 0) {
kprintf("load address: 0x%08x size: %d\n", ph->p_va,
ph->p_memsz);
goto bad_cleanup_mmap;
}
if (load_address_flag == 0)
load_address = ph->p_va + bias;
++load_address_flag;
/*********************************************/
/*
vm_flags = 0;
ptep_set_u_read(&perm);
if (ph->p_flags & ELF_PF_X) vm_flags |= VM_EXEC;
if (ph->p_flags & ELF_PF_W) vm_flags |= VM_WRITE;
if (ph->p_flags & ELF_PF_R) vm_flags |= VM_READ;
if (vm_flags & VM_WRITE) ptep_set_u_write(&perm);
if ((ret = mm_map(mm, ph->p_va, ph->p_memsz, vm_flags, NULL)) != 0) {
goto bad_cleanup_mmap;
}
if (mm->brk_start < ph->p_va + ph->p_memsz) {
mm->brk_start = ph->p_va + ph->p_memsz;
}
off_t offset = ph->p_offset;
size_t off, size;
uintptr_t start = ph->p_va, end, la = ROUNDDOWN(start, PGSIZE);
end = ph->p_va + ph->p_filesz;
while (start < end) {
if ((page = pgdir_alloc_page(mm->pgdir, la, perm)) == NULL) {
ret = -E_NO_MEM;
goto bad_cleanup_mmap;
}
off = start - la, size = PGSIZE - off, la += PGSIZE;
if (end < la) {
size -= la - end;
}
if ((ret = load_icode_read(fd, page2kva(page) + off, size, offset)) != 0) {
goto bad_cleanup_mmap;
}
start += size, offset += size;
}
end = ph->p_va + ph->p_memsz;
if (start < la) {
// ph->p_memsz == ph->p_filesz
if (start == end) {
continue ;
}
off = start + PGSIZE - la, size = PGSIZE - off;
if (end < la) {
size -= la - end;
}
memset(page2kva(page) + off, 0, size);
start += size;
assert((end < la && start == end) || (end >= la && start == la));
}
while (start < end) {
if ((page = pgdir_alloc_page(mm->pgdir, la, perm)) == NULL) {
ret = -E_NO_MEM;
goto bad_cleanup_mmap;
}
off = start - la, size = PGSIZE - off, la += PGSIZE;
if (end < la) {
size -= la - end;
}
memset(page2kva(page) + off, 0, size);
start += size;
}
*/
/**************************************/
}
mm->brk_start = mm->brk = ROUNDUP(mm->brk_start, PGSIZE);
/* setup user stack */
vm_flags = VM_READ | VM_WRITE | VM_STACK;
if ((ret =
mm_map(mm, USTACKTOP - USTACKSIZE, USTACKSIZE, vm_flags,
NULL)) != 0) {
goto bad_cleanup_mmap;
}
if (is_dynamic) {
elf->e_entry += bias;
bias = 0;
off_t phoff =
elf->e_phoff + sizeof(struct proghdr) * interp_idx;
if ((ret =
load_icode_read(fd, ph, sizeof(struct proghdr),
phoff)) != 0) {
goto bad_cleanup_mmap;
}
char *interp_path = (char *)kmalloc(ph->p_filesz);
load_icode_read(fd, interp_path, ph->p_filesz, ph->p_offset);
int interp_fd = sysfile_open(interp_path, O_RDONLY);
assert(interp_fd >= 0);
struct elfhdr interp___elf, *interp_elf = &interp___elf;
assert((ret =
load_icode_read(interp_fd, interp_elf,
sizeof(struct elfhdr), 0)) == 0);
assert(interp_elf->e_magic == ELF_MAGIC);
struct proghdr interp___ph, *interp_ph = &interp___ph;
uint32_t interp_phnum;
uint32_t va_min = 0xffffffff, va_max = 0;
for (interp_phnum = 0; interp_phnum < interp_elf->e_phnum;
++interp_phnum) {
off_t interp_phoff =
interp_elf->e_phoff +
sizeof(struct proghdr) * interp_phnum;
assert((ret =
load_icode_read(interp_fd, interp_ph,
sizeof(struct proghdr),
interp_phoff)) == 0);
if (interp_ph->p_type != ELF_PT_LOAD) {
continue;
}
if (va_min > interp_ph->p_va)
va_min = interp_ph->p_va;
if (va_max < interp_ph->p_va + interp_ph->p_memsz)
va_max = interp_ph->p_va + interp_ph->p_memsz;
}
bias = get_unmapped_area(mm, va_max - va_min + 1 + PGSIZE);
bias = ROUNDUP(bias, PGSIZE);
for (interp_phnum = 0; interp_phnum < interp_elf->e_phnum;
++interp_phnum) {
off_t interp_phoff =
interp_elf->e_phoff +
sizeof(struct proghdr) * interp_phnum;
assert((ret =
load_icode_read(interp_fd, interp_ph,
sizeof(struct proghdr),
interp_phoff)) == 0);
if (interp_ph->p_type != ELF_PT_LOAD) {
continue;
}
assert((ret =
map_ph(interp_fd, interp_ph, mm, &bias,
1)) == 0);
}
real_entry = interp_elf->e_entry + bias;
sysfile_close(interp_fd);
kfree(interp_path);
}
sysfile_close(fd);
bool intr_flag;
local_intr_save(intr_flag);
{
list_add(&(proc_mm_list), &(mm->proc_mm_link));
}
local_intr_restore(intr_flag);
mm_count_inc(mm);
current->mm = mm;
set_pgdir(current, mm->pgdir);
mm->cpuid = myid();
mp_set_mm_pagetable(mm);
if (!is_dynamic) {
real_entry += bias;
}
#ifdef UCONFIG_BIONIC_LIBC
if (init_new_context_dynamic(current, elf, argc, kargv, envc, kenvp,
is_dynamic, real_entry, load_address,
bias) < 0)
goto bad_cleanup_mmap;
#else
if (init_new_context(current, elf, argc, kargv, envc, kenvp) < 0)
goto bad_cleanup_mmap;
#endif //UCONFIG_BIONIC_LIBC
ret = 0;
out:
return ret;
bad_cleanup_mmap:
exit_mmap(mm);
bad_elf_cleanup_pgdir:
put_pgdir(mm);
bad_pgdir_cleanup_mm:
mm_destroy(mm);
bad_mm:
goto out;
}
/*
* If minsize >= 0, and the file is smaller than maxsize, load the data
* into the end of the memory range.
* If minsize < 0, load it at the start.
*/
int sysfile_load(const char *name, BYTE *dest, int minsize, int maxsize)
{
FILE *fp = NULL;
size_t rsize = 0;
char *complete_path = NULL;
int load_at_end;
/*
* This feature is only active when --enable-embedded is given to the
* configure script, its main use is to make developing new ports easier
* and to allow ports for platforms which don't have a filesystem, or a
* filesystem which is hard/impossible to load data files from.
*
* when USE_EMBEDDED is defined this will check if a
* default system file is loaded, when USE_EMBEDDED
* is not defined the function is just 0 and will
* be optimized away.
*/
if ((rsize = embedded_check_file(name, dest, minsize, maxsize)) != 0) {
return rsize;
}
fp = sysfile_open(name, &complete_path, MODE_READ);
if (fp == NULL) {
/* Try to open the file from the current directory. */
const char working_dir_prefix[3] = {
'.', FSDEV_DIR_SEP_CHR, '\0'
};
char *local_name = NULL;
local_name = util_concat(working_dir_prefix, name, NULL);
fp = sysfile_open((const char *)local_name, &complete_path, MODE_READ);
lib_free(local_name);
local_name = NULL;
if (fp == NULL) {
goto fail;
}
}
log_message(LOG_DEFAULT, "Loading system file `%s'.", complete_path);
rsize = util_file_length(fp);
if (minsize < 0) {
minsize = -minsize;
load_at_end = 0;
} else {
load_at_end = 1;
}
if (rsize < ((size_t)minsize)) {
log_error(LOG_DEFAULT, "ROM %s: short file.", complete_path);
goto fail;
}
if (rsize == ((size_t)maxsize + 2)) {
log_warning(LOG_DEFAULT,
"ROM `%s': two bytes too large - removing assumed "
"start address.", complete_path);
if (fread((char *)dest, 1, 2, fp) < 2) {
goto fail;
}
rsize -= 2;
}
if (load_at_end && rsize < ((size_t)maxsize)) {
dest += maxsize - rsize;
} else if (rsize > ((size_t)maxsize)) {
log_warning(LOG_DEFAULT, "ROM `%s': long file, discarding end.",
complete_path);
rsize = maxsize;
}
if ((rsize = fread((char *)dest, 1, rsize, fp)) < ((size_t)minsize)) {
goto fail;
}
fclose(fp);
lib_free(complete_path);
return (int)rsize; /* return ok */
fail:
lib_free(complete_path);
return -1;
}
static bool loadSound(const unsigned id)
{
sound_t ** sound;
file_t fp;
wave_header_t header;
U16 u16Temp;
U32 u32Temp;
int bytesRead;
bool isHeaderValid;
if (!fromResourceIdToSound(id, &sound))
{
return false;
}
*sound = sysmem_push(sizeof(**sound));
if (!*sound)
{
return false;
}
(*sound)->buf = NULL;
(*sound)->dispose = true; /* sounds are "fire and forget" by default */
(*sound)->name = u_strdup(resourceFiles[id]);
if (!(*sound)->name)
{
return false;
}
fp = sysfile_open(resourceFiles[id]);
if (!fp)
{
sys_error("(resources) unable to open \"%s\"", resourceFiles[id]);
return false;
}
bytesRead = sysfile_read(fp, &header, sizeof(header), 1);
sysfile_close(fp);
if (bytesRead != 1)
{
sys_error("(resources) unable to read WAVE header from \"%s\"", resourceFiles[id]);
return false;
}
isHeaderValid = false;
for (;;)
{
if (memcmp(header.riffChunkId, "RIFF", 4) ||
memcmp(header.riffType, "WAVE", 4) ||
memcmp(header.formatChunkId, "fmt ", 4) ||
memcmp(header.dataChunkId, "data", 4))
{
break;
}
memcpy(&u16Temp, header.audioFormat, sizeof(u16Temp));
if (letoh16(u16Temp) != Wave_AUDIO_FORMAT)
{
break;
}
memcpy(&u16Temp, header.channelCount, sizeof(u16Temp));
if (letoh16(u16Temp) != Wave_CHANNEL_COUNT)
{
break;
}
memcpy(&u32Temp, header.sampleRate, sizeof(u32Temp));
if (letoh32(u32Temp) != Wave_SAMPLE_RATE)
{
isHeaderValid = false;
break;
}
memcpy(&u16Temp, header.bitsPerSample, sizeof(u16Temp));
if (letoh16(u16Temp) != Wave_BITS_PER_SAMPLE)
{
isHeaderValid = false;
break;
}
memcpy(&u32Temp, header.dataChunkSize, sizeof(u32Temp));
(*sound)->len = letoh32(u32Temp);
isHeaderValid = true;
break;
}
if (!isHeaderValid)
{
sys_error("(resources) incompatible WAVE header for \"%s\"", resourceFiles[id]);
return false;
}
return true;
}
int
do_execve(const char *filename, const char **argv, const char **envp) {
static_assert(EXEC_MAX_ARG_LEN >= FS_MAX_FPATH_LEN);
struct mm_struct *mm = current->mm;
char local_name[PROC_NAME_LEN + 1];
memset(local_name, 0, sizeof(local_name));
char *kargv[EXEC_MAX_ARG_NUM], *kenvp[EXEC_MAX_ENV_NUM];
const char *path;
int ret = -E_INVAL;
lock_mm(mm);
#if 0
if (name == NULL) {
snprintf(local_name, sizeof(local_name), "<null> %d", current->pid);
}
else {
if (!copy_string(mm, local_name, name, sizeof(local_name))) {
unlock_mm(mm);
return ret;
}
}
#endif
snprintf(local_name, sizeof(local_name), "<null> %d", current->pid);
int argc = 0, envc = 0;
if ((ret = copy_kargv(mm, kargv, argv, EXEC_MAX_ARG_NUM, &argc)) != 0) {
unlock_mm(mm);
return ret;
}
if ((ret = copy_kargv(mm, kenvp, envp, EXEC_MAX_ENV_NUM, &envc)) != 0) {
unlock_mm(mm);
put_kargv(argc, kargv);
return ret;
}
#if 0
int i;
kprintf("## fn %s\n", filename);
kprintf("## argc %d\n", argc);
for(i=0;i<argc;i++)
kprintf("## %08x %s\n", kargv[i], kargv[i]);
kprintf("## envc %d\n", envc);
for(i=0;i<envc;i++)
kprintf("## %08x %s\n", kenvp[i], kenvp[i]);
#endif
//path = argv[0];
//copy_from_user (mm, &path, argv, sizeof (char*), 0);
path = filename;
unlock_mm(mm);
/* linux never do this */
//fs_closeall(current->fs_struct);
/* sysfile_open will check the first argument path, thus we have to use a user-space pointer, and argv[0] may be incorrect */
int fd;
if ((ret = fd = sysfile_open(path, O_RDONLY)) < 0) {
goto execve_exit;
}
if (mm != NULL) {
mm->lapic = -1;
mp_set_mm_pagetable(NULL);
if (mm_count_dec(mm) == 0) {
exit_mmap(mm);
put_pgdir(mm);
bool intr_flag;
local_intr_save(intr_flag);
{
list_del(&(mm->proc_mm_link));
}
local_intr_restore(intr_flag);
mm_destroy(mm);
}
current->mm = NULL;
}
put_sem_queue(current);
ret = -E_NO_MEM;
/* init signal */
put_sighand(current);
if ((current->signal_info.sighand = sighand_create()) == NULL) {
goto execve_exit;
}
sighand_count_inc(current->signal_info.sighand);
put_signal(current);
if ((current->signal_info.signal = signal_create()) == NULL) {
goto execve_exit;
}
signal_count_inc(current->signal_info.signal);
if ((current->sem_queue = sem_queue_create()) == NULL) {
goto execve_exit;
}
sem_queue_count_inc(current->sem_queue);
if ((ret = load_icode(fd, argc, kargv, envc, kenvp)) != 0) {
goto execve_exit;
}
set_proc_name(current, local_name);
if (do_execve_arch_hook (argc, kargv) < 0)
goto execve_exit;
put_kargv(argc, kargv);
return 0;
execve_exit:
put_kargv(argc, kargv);
put_kargv(envc, kenvp);
/* exec should return -1 if failed */
//return ret;
do_exit(ret);
panic("already exit: %e.\n", ret);
}
static bool readFile(const unsigned id)
{
bool success;
file_t fp;
void * vp;
switch (id)
{
#ifndef GFXST
case Resource_PICHAF: /* fallthrough */
case Resource_PICCONGRATS: /* fallthrough */
case Resource_PICSPLASH: return true;
#endif /* ndef GFXST */
#ifndef GFXPC
case Resource_IMAINHOFT: /* fallthrough */
case Resource_IMAINRDT: /* fallthrough */
case Resource_IMAINCDC: /* fallthrough */
case Resource_SCREENCONGRATS: return true;
#endif /* ndef GFXPC */
default: break;
}
if (resourceFiles[id] == NULL)
{
sys_error("(resources) resource ID %d not available", id);
return false;
}
if (!checkCrc32(id))
{
return false;
}
fp = sysfile_open(resourceFiles[id]);
if (fp == NULL)
{
sys_error("(resources) unable to open \"%s\"", resourceFiles[id]);
return false;
}
success = readHeader(fp, id);
if (success)
{
switch (id)
{
case Resource_FILELIST: success = loadResourceFilelist(fp); break;
case Resource_PALETTE:
{
vp = game_colors;
success = loadRawData(fp, &vp, sizeof(*game_colors), &game_color_count);
game_colors = vp;
break;
}
case Resource_ENTDATA: success = loadResourceEntdata(fp); break;
case Resource_SPRSEQ:
{
vp = ent_sprseq;
success = loadRawData(fp, &vp, sizeof(*ent_sprseq), &ent_nbr_sprseq);
ent_sprseq = vp;
break;
}
case Resource_MVSTEP:
{
vp = ent_mvstep;
success = loadRawData(fp, &vp, sizeof(*ent_mvstep), &ent_nbr_mvstep);
ent_mvstep = vp;
break;
}
case Resource_MAPS: success = loadResourceMaps(fp); break;
case Resource_SUBMAPS: success = loadResourceSubmaps(fp); break;
case Resource_CONNECT:
{
vp = map_connect;
success = loadRawData(fp, &vp, sizeof(*map_connect), &map_nbr_connect);
map_connect = vp;
break;
}
case Resource_BNUMS:
{
vp = map_bnums;
success = loadRawData(fp, &vp, sizeof(*map_bnums), &map_nbr_bnums);
map_bnums = vp;
break;
}
case Resource_BLOCKS:
{
vp = map_blocks;
success = loadRawData(fp, &vp, sizeof(*map_blocks), &map_nbr_blocks);
map_blocks = vp;
break;
}
case Resource_MARKS:
{
vp = map_marks;
success = loadRawData(fp, &vp, sizeof(*map_marks), &map_nbr_marks);
map_marks = vp;
break;
}
case Resource_EFLGC:
{
vp = map_eflg_c;
success = loadRawData(fp, &vp, sizeof(*map_eflg_c), &map_nbr_eflgc);
map_eflg_c = vp;
break;
}
case Resource_IMAPSL:
{
vp = screen_imapsl;
success = loadRawData(fp, &vp, sizeof(*screen_imapsl), &screen_nbr_imapsl);
screen_imapsl = vp;
break;
}
case Resource_IMAPSTEPS: success = loadResourceImapsteps(fp); break;
case Resource_IMAPSOFS:
{
vp = screen_imapsofs;
success = loadRawData(fp, &vp, sizeof(*screen_imapsofs), &screen_nbr_imapsofs);
screen_imapsofs = vp;
break;
}
case Resource_IMAPTEXT: success = loadResourceImaptext(fp); break;
case Resource_GAMEOVERTXT: success = loadString(fp, (char **)(&screen_gameovertxt), 0xFE); break;
case Resource_PAUSEDTXT: success = loadString(fp, (char **)(&screen_pausedtxt), 0xFE); break;
case Resource_SPRITESDATA: success = loadResourceSpritesData(fp); break;
case Resource_TILESDATA: success = loadResourceTilesData(fp); break;
case Resource_HIGHSCORES: success = loadResourceHighScores(fp); break;
case Resource_IMGSPLASH: success = loadImage(fp, &img_splash); break;
#ifdef GFXST
case Resource_PICHAF: success = loadPicture(fp, &pic_haf); break;
case Resource_PICCONGRATS: success = loadPicture(fp, &pic_congrats); break;
case Resource_PICSPLASH: success = loadPicture(fp, &pic_splash); break;
#endif /* GFXST */
#ifdef GFXPC
case Resource_IMAINHOFT: success = loadString(fp, (char **)(&screen_imainhoft), 0xFE); break;
case Resource_IMAINRDT: success = loadString(fp, (char **)(&screen_imainrdt), 0xFE); break;
case Resource_IMAINCDC: success = loadString(fp, (char **)(&screen_imaincdc), 0xFE); break;
case Resource_SCREENCONGRATS: success = loadString(fp, (char **)(&screen_congrats), 0xFE); break;
#endif /* GFXPC */
default: success = false; break;
}
}
if (!success)
{
sys_error("(resources) error when parsing \"%s\"", resourceFiles[id]);
}
sysfile_close(fp);
return success;
}
HACCEL uikeyboard_create_accelerator_table(void)
{
FILE *fshortcuts;
char *complete_path;
char buffer[1000];
char *p, *menustr, *metastr, *keystr, *displaystr;
int i;
accelnum = 0;
menuitemmodifier_len = 0;
for (i = 0; idmlist[i].str != NULL; i++) {
if (idmlist[i].cmd >= menuitemmodifier_len) {
menuitemmodifier_len = idmlist[i].cmd + 1;
}
}
menuitemmodifier = lib_calloc(menuitemmodifier_len, sizeof(char*));
memset(menuitemmodifier, 0, menuitemmodifier_len * sizeof(char*));
fshortcuts = sysfile_open("win_shortcuts.vsc", &complete_path, MODE_READ_TEXT);
lib_free(complete_path);
if (fshortcuts == NULL) {
log_error(LOG_DEFAULT, "Warning. Cannot open keyboard shortcut file win_shortcuts.vsc.");
return NULL;
}
/* read the shortcut table */
do {
buffer[0] = 0;
if (fgets(buffer, 999, fshortcuts)) {
if (strlen(buffer) == 0) {
break;
}
buffer[strlen(buffer) - 1] = 0; /* remove newline */
/* remove comments */
if ((p = strchr(buffer, '#'))) {
*p = 0;
}
metastr = strtok(buffer, " \t:");
keystr = strtok(NULL, " \t:");
menustr = strtok(NULL, " \t:");
displaystr = strtok(NULL, " \t:");
if (displaystr && (p = strchr(displaystr, '#'))) {
*p = 0;
}
if (metastr && keystr && menustr) {
for (i = 0; idmlist[i].str; i++) {
if (strcmp(idmlist[i].str, menustr) == 0) {
break;
}
}
if (idmlist[i].str) {
ACCEL accel;
accel.fVirt = FVIRTKEY | FNOINVERT;
if (strstr(strlwr(metastr), "shift") != NULL) {
accel.fVirt |= FSHIFT;
}
if (strstr(strlwr(metastr), "ctrl") != NULL) {
accel.fVirt |= FCONTROL;
}
if (strstr(strlwr(metastr), "alt") != NULL) {
accel.fVirt |= FALT;
}
if (keystr[0] == '\'' && keystr[2] == '\'') {
accel.key = keystr[1];
if (displaystr == NULL || displaystr[0] == 0) {
displaystr = keystr + 1;
keystr[2] = 0;
}
} else {
accel.key = (unsigned short)strtol(keystr, NULL, 0);
}
accel.cmd = idmlist[i].cmd;
if (accel.key > 0 && accel.cmd > 0 && accelnum < MAXACCEL) {
accellist[accelnum++] = accel;
}
if (displaystr != NULL && menuitemmodifier[accel.cmd] == NULL) {
p = util_concat("\t",
((accel.fVirt & FSHIFT ) ? "Shift+" : ""),
((accel.fVirt & FCONTROL) ? "Ctrl+" : ""),
((accel.fVirt & FALT) ? "Alt+" : ""),
displaystr, NULL);
menuitemmodifier[accel.cmd] = p;
}
}
}
}
} while (!feof(fshortcuts));
fclose(fshortcuts);
return CreateAcceleratorTable(accellist, accelnum);
}
