Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 913 → Rev 914

/kernel/branches/kolibri_pe/core/dll.c
277,12 → 277,13
( raw[1] == 0x30305445) ) )
 
{
DBG("leagacy Kolibri application\n");
DBG("leagacy Kolibri application");
int tmp = mnt_exec(raw, raw_size, path, cmdline, flags);
DBG(" pid %x\n",tmp);
return tmp;
}
 
if( ! validate_pe(raw, raw_size) )
if( ! validate_pe(raw, raw_size, true) )
{
DBG("invalid executable file %s\n", path);
mem_free(raw);
289,6 → 290,9
return -31;
}
 
dos = (PIMAGE_DOS_HEADER)raw;
nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
 
pathsize = strlen(path)+1;
 
if( cmdline )
359,8 → 363,7
DBG("create stack at %x\n\tpath %x\n\tcmdline %x\n",
ex_stack, ex_stack->path, ex_stack->cmdline);
 
pe_app_param(path, raw, ex_pg_dir, ex_stack);
return 0;
return pe_app_param(path, raw, ex_pg_dir, ex_stack);
};
 
#define master_tab (page_tabs+ (page_tabs>>10))
394,6 → 397,10
 
size_t img_size;
count_t img_pages;
size_t stack_size;
addr_t img_stack;
addr_t *pte;
 
count_t i;
u32_t tmp;
 
408,19 → 415,27
 
list_initialize(&current_slot->dll_list);
 
pte = (addr_t*)page_tabs;
img_pages = img_size >> 12;
 
for(i = 0; i < img_pages; i++)
{
addr_t page = core_alloc(0);
((u32_t*)page_tabs)[i] = page | 7; /* FIXME */
}
stack_size = (nt->OptionalHeader.SizeOfStackReserve + 4095) & ~4095;
img_stack = 0x7FFFF000 - stack_size;
stack_size>>= 12;
 
while (img_pages--)
*pte++ = 2;
 
pte = &((addr_t*)page_tabs)[img_stack>>12];
 
while(stack_size--)
*pte++ = 0x02;
 
addr_t stack_page = ((addr_t)ex_stack-OS_BASE) & ~4095;
((u32_t*)page_tabs)[0x7FFFF000>>12] = stack_page | 7;
 
create_image(0, raw);
*pte = stack_page | 7;
 
create_image(0, raw, false);
 
init_user_heap();
 
if (! link_pe(0))
430,6 → 445,7
"int $0x40"::"a"(-1));
};
 
 
// __asm__ __volatile__ (
// "xchgw %bx, %bx");
 
481,7 → 497,7
return NULL;
};
 
if( ! validate_pe(raw, raw_size) )
if( ! validate_pe(raw, raw_size, false) )
{
DBG("invalid pe file %s\n", path);
mem_free(raw);
508,7 → 524,7
return NULL;
};
 
create_image(img_base, (addr_t)raw);
create_image(img_base, (addr_t)raw, false);
 
mem_free(raw);
 
609,6 → 625,7
{
PIMAGE_IMPORT_BY_NAME ord;
addr_t addr;
*iat=0;
 
if ( thunk->u1.AddressOfData == 0 )
break;
615,7 → 632,9
 
if ( thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG )
{
// printf(" %4u\n", thunk->u1.Ordinal & 0xFFFF);
u16_t ordinal;
ordinal = thunk->u1.Ordinal & 0xFFFF;
*iat = functions[ordinal-exp->Base] + exp_dll->img_base;
break;
}
else
622,7 → 641,6
{
ord = MakePtr(PIMAGE_IMPORT_BY_NAME,
thunk->u1.AddressOfData, img_base);
*iat=0;
 
DBG("import %s", ord->Name);
 
639,7 → 657,7
{
u16_t ordinal;
ordinal = ordinals[ind];
DBG(" \t\tat %x\n", functions[ordinal] + exp_dll->img_base);
DBG("ordinal %d\t\tat %x\n", ordinal, functions[ordinal] + exp_dll->img_base);
*iat = functions[ordinal] + exp_dll->img_base;
break;
};
/kernel/branches/kolibri_pe/core/export.asm
3,7 → 3,7
 
 
.section .drectve
.ascii " -export:CreateImage" # cdecl
# .ascii " -export:CreateImage" # cdecl
.ascii " -export:LoadFile" # stdcall
 
.ascii " -export:Kmalloc" # eax FIXME
/kernel/branches/kolibri_pe/core/heap.inc
32,20 → 32,20
sub eax, 4096
ret
@@:
mov esi, [ebx+APPDATA.mem_size]
add esi, 4095
and esi, not 4095
mov [ebx+APPDATA.mem_size], esi
mov edx, [ebx+APPDATA.mem_size]
add edx, 4095
and edx, not 4095
mov [ebx+APPDATA.mem_size], edx
mov eax, HEAP_TOP
mov [ebx+APPDATA.heap_base], esi
mov [ebx+APPDATA.heap_base], edx
mov [ebx+APPDATA.heap_top], eax
 
sub eax, esi
shr esi, 10
sub eax, edx
shr edx, 10
mov ecx, eax
sub eax, 4096
or ecx, FREE_BLOCK
mov [page_tabs+esi], ecx
mov [page_tabs+edx], ecx
ret
 
align 4
/kernel/branches/kolibri_pe/core/pe.c
40,7 → 40,6
 
int __stdcall strncmp(const char *s1, const char *s2, size_t n);
 
void __export create_image(addr_t img_base, addr_t raw) asm ("CreateImage");
bool link_image(addr_t img_base);
 
md_t* __fastcall load_image(const char *path);
59,7 → 58,7
};
*/
 
bool validate_pe(void *raw, size_t raw_size)
bool validate_pe(void *raw, size_t raw_size, bool is_exec)
{
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS32 nt;
80,9 → 79,18
if(nt->Signature != IMAGE_NT_SIGNATURE)
return false;
 
if(nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
return false;
 
if(is_exec && (nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
return false;
 
if(nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
return false;
 
if( is_exec && nt->OptionalHeader.ImageBase != 0)
return false;
 
if(nt->OptionalHeader.SectionAlignment < PAGE_SIZE)
{
if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment)
127,7 → 135,7
return NULL;
};
 
if( ! validate_pe(raw, raw_size) )
if( ! validate_pe(raw, raw_size, false) )
{
DBG("invalid pe file %s\n", path);
mem_free(raw);
150,7 → 158,7
 
img_base = img_md->base;
 
create_image(img_base, (addr_t)raw);
create_image(img_base, (addr_t)raw, true);
 
mem_free(raw);
 
190,7 → 198,7
*/
 
 
void create_image(addr_t img_base, addr_t raw)
void create_image(addr_t img_base, addr_t raw, bool force_clear)
{
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS32 nt;
223,13 → 231,16
if(img_sec->SizeOfRawData)
sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData);
 
if(force_clear)
{
sec_size = (img_sec->Misc.VirtualSize + sec_align -1) & -sec_align;
 
if(sec_size > img_sec->SizeOfRawData)
sec_clear(dest_ptr + img_sec->SizeOfRawData,
sec_size - img_sec->SizeOfRawData);
};
img_sec++;
}
};
 
if(nt->OptionalHeader.DataDirectory[5].Size)
{
/kernel/branches/kolibri_pe/core/taskman.inc
146,11 → 146,12
test al, al
jnz @b
 
lea edi, [cmdline]
mov dword [edi],0
mov esi, [cmd_line]
test esi, esi
jz .no_cmdline
 
lea edi, [cmdline]
lea ecx, [edi+255]
mov [edi+252], dword 0
@@:
226,8 → 227,8
 
mov ecx, [hdr_mem]
mov edi, [file_size]
add edi, 4095
and edi, not 4095
; add edi, 4095
; and edi, not 4095
sub ecx, edi
jna @F
 
246,8 → 247,8
mov eax, [save_cr3]
call set_cr3
 
mov eax,[process_number] ;set result
mov [application_table_status], 0 ;unlock application_table_status mutex
mov eax,[process_number] ;set result
 
pop edi
pop esi
433,8 → 434,8
 
DEBUGF 1,"%s",new_process_running
.err:
mov eax,[process_number] ;set result
mov [application_table_status], 0 ;unlock application_table_status mutex
mov eax,[process_number] ;set result
 
pop edi
pop esi