WebSVN – Kolibri OS – Diff – /programs/develop/libraries/newlib/pe/loader.c


#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
#include 
 
#include "list.h"
#include "pe.h"
 
#define unlikely(x)     __builtin_expect(!!(x), 0)
 
//#define DBG(format,...) printf(format,##__VA_ARGS__)
 
#define DBG(format,...)
 
 
void      __fastcall init_loader(void *libc_image);
void*     __fastcall create_image(void *raw);
int       __fastcall link_image(void *img_base);
int       __fastcall do_exec(uint32_t my_app, uint32_t *params);
 
 
extern char* __appenv;
extern int   __appenv_size;
 
typedef struct tag_module module_t;
 
struct app_hdr
{
    char  banner[8];
    int   version;
    int   start;
    int   iend;
    int   memsize;
    int   stacktop;
    char  *cmdline;
    char  *path;
};
 
struct tag_module
{
    struct list_head list;
 
    char       *img_name;
    char       *img_path;
 
    uint32_t    refcount;
 
    void       *start;
    uint32_t    end;
 
    void       *entry;
 
    PIMAGE_NT_HEADERS32      img_hdr;
    PIMAGE_SECTION_HEADER    img_sec;
    PIMAGE_EXPORT_DIRECTORY  img_exp;
};
 
typedef struct
{
    struct list_head list;
    char *path;
    int   path_len;
}dll_path_t;
 
module_t* load_module(const char *name);
 
LIST_HEAD(dll_list);
LIST_HEAD(path_list);
 
static module_t libc_dll;
static char libc_name[] = "libc.dll";
static char libc_path[] = "/sys/lib/libc.dll";
 
static inline int IsPowerOf2(uint32_t val)
{
    if(val == 0)
        return 0;
    return (val & (val - 1)) == 0;
}
 
 
int validate_pe(void *raw, size_t raw_size, int is_exec)
{
    PIMAGE_DOS_HEADER     dos;
    PIMAGE_NT_HEADERS32   nt;
 
    dos = (PIMAGE_DOS_HEADER)raw;
 
    if( !raw || raw_size < sizeof(IMAGE_DOS_HEADER) )
        return 0;
 
    if( dos->e_magic != IMAGE_DOS_SIGNATURE || dos->e_lfanew <= 0)
        return 0;
 
    nt =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
 
    if( (uint32_t)nt < (uint32_t)raw)
        return 0;
 
    if(nt->Signature != IMAGE_NT_SIGNATURE)
        return 0;
 
    if(nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
        return 0;
 
    if(is_exec && (nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
        return 0;
 
    if(nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
        return 0;
 
    if( is_exec && nt->OptionalHeader.ImageBase != 0)
        return 0;
 
    if(nt->OptionalHeader.SectionAlignment < 4096)
    {
        if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment)
            return 0;
    }
    else if(nt->OptionalHeader.SectionAlignment < nt->OptionalHeader.FileAlignment)
        return 0;
 
    if(!IsPowerOf2(nt->OptionalHeader.SectionAlignment) ||
       !IsPowerOf2(nt->OptionalHeader.FileAlignment))
        return 0;
 
    if(nt->FileHeader.NumberOfSections > 96)
        return 0;
 
    return 1;
}
 
 
void __fastcall init_loader(void *libc_image)
{
 
    PIMAGE_DOS_HEADER        dos;
    PIMAGE_NT_HEADERS32      nt;
    PIMAGE_EXPORT_DIRECTORY  exp;
 
    struct   app_hdr *header;
 
    dll_path_t *path;
    int len;
    char *p;
 
    if(__appenv_size)
    {
        char *env;
        env = envz_get(__appenv, __appenv_size, "PATH");
        if( env )
        {
            while( *env )
            {
                p = env;
                while(*p)
                {
                    if( *p == 0x0D)
                        break;
                    else if( *p == 0x0A)
                        break;
                    else if( *p == ':')
                        break;
                    p++;
                };
                len = p-env;
                if(len)
                {
                    char *p1;
 
                    p1 = (char*)malloc(len+1);
                    memcpy(p1, env, len);
                    p1[len]=0;
 
                    path = (dll_path_t*)malloc(sizeof(dll_path_t));
                    INIT_LIST_HEAD(&path->list);
                    path->path = p1;
                    path->path_len = len;
                    DBG("add libraries path %s\n", path->path);
                    list_add_tail(&path->list, &path_list);
                };
                if(*p == ':')
                {
                    env = p+1;
                    continue;
                }
                else break;
            };
        };
    };
 
    header = (struct app_hdr*)NULL;
 
    len = strrchr(header->path, '/') - header->path+1;
    p = (char*)malloc(len+1);
    memcpy(p, header->path, len);
    p[len]=0;
 
    path = (dll_path_t*)malloc(sizeof(dll_path_t));
    INIT_LIST_HEAD(&path->list);
    path->path = p;
    path->path_len = len;
    DBG("add libraries path %s\n", path->path);
    list_add_tail(&path->list, &path_list);
 
 
#if 0
    path = (dll_path_t*)malloc(sizeof(dll_path_t));
    INIT_LIST_HEAD(&path->list);
    path->path = "/sys/lib/";
    path->path_len = 9;                           /* FIXME */
    DBG("add libraries path %s\n", path->path);
    list_add_tail(&path->list, &path_list);
#endif
 
    INIT_LIST_HEAD(&libc_dll.list);
 
    libc_dll.img_name = libc_name;
    libc_dll.img_path = libc_path;
 
    libc_dll.refcount = 1;
 
    dos =  (PIMAGE_DOS_HEADER)libc_image;
    nt  =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
    exp =  MakePtr(PIMAGE_EXPORT_DIRECTORY, libc_image,
                   nt->OptionalHeader.DataDirectory[0].VirtualAddress);
 
    libc_dll.start = libc_image;
    libc_dll.end   = MakePtr(uint32_t,libc_image, nt->OptionalHeader.SizeOfImage);
 
    libc_dll.img_hdr  = nt;
    libc_dll.img_sec  = MakePtr(PIMAGE_SECTION_HEADER,nt, sizeof(IMAGE_NT_HEADERS32));
    libc_dll.img_exp  = MakePtr(PIMAGE_EXPORT_DIRECTORY,libc_image,
                        nt->OptionalHeader.DataDirectory[0].VirtualAddress);
 
    list_add_tail(&libc_dll.list, &dll_list);
};
 
const module_t* find_module(const char *name)
{
    module_t* mod;
 
    list_for_each_entry(mod, &dll_list, list)
    {
        if( !strncmp(name, mod->img_name, 16))
            return mod;
    };
 
    return load_module(name);
};
 
static inline void sec_copy(void *dst, void *src, size_t len)
{
    __asm__ __volatile__ (
    "shrl $2, %%ecx         \n\t"
    "rep movsl"
    :
    :"c"(len),"S"(src),"D"(dst)
    :"cc");
    __asm__ __volatile__ (
    ""
    :::"ecx","esi","edi");
};
 
static inline void *user_alloc(size_t size)
{
    void *val;
    __asm__ __volatile__(
    "int $0x40"
    :"=eax"(val)
    :"a"(68),"b"(12),"c"(size));
    return val;
}
 
void* __fastcall create_image(void *raw)
{
    PIMAGE_DOS_HEADER     dos;
    PIMAGE_NT_HEADERS32   nt;
    PIMAGE_SECTION_HEADER img_sec;
 
    void  *img_base;
    uint32_t  sec_align;
    int    i;
 
    dos = (PIMAGE_DOS_HEADER)raw;
    nt =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
 
    img_base = user_alloc(nt->OptionalHeader.SizeOfImage);
 
    if(unlikely(img_base == NULL))
        return 0;
 
    sec_copy(img_base, raw, nt->OptionalHeader.SizeOfHeaders);
 
    img_sec = MakePtr(PIMAGE_SECTION_HEADER, nt, sizeof(IMAGE_NT_HEADERS32));
 
    sec_align = nt->OptionalHeader.SectionAlignment;
 
    for(i=0; i< nt->FileHeader.NumberOfSections; i++)
    {
        void *src_ptr;
        void *dest_ptr;
        size_t   sec_size;
 
        if ( img_sec->SizeOfRawData && img_sec->PointerToRawData )
        {
            src_ptr  = MakePtr(void*, raw, img_sec->PointerToRawData);
            dest_ptr = MakePtr(void*, img_base, img_sec->VirtualAddress);
            sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData);
        };
 
        img_sec++;
    };
 
    if(nt->OptionalHeader.DataDirectory[5].Size)
    {
        PIMAGE_BASE_RELOCATION reloc;
 
        uint32_t delta = (uint32_t)img_base - nt->OptionalHeader.ImageBase;
 
        reloc = MakePtr(PIMAGE_BASE_RELOCATION, img_base,
                        nt->OptionalHeader.DataDirectory[5].VirtualAddress);
 
        while ( reloc->SizeOfBlock != 0 )
        {
            uint32_t  cnt;
            uint16_t *entry;
            uint16_t  reltype;
            uint32_t  offs;
 
            cnt = (reloc->SizeOfBlock - sizeof(*reloc))/sizeof(uint16_t);
            entry = MakePtr( uint16_t*, reloc, sizeof(*reloc) );
 
            for ( i=0; i < cnt; i++ )
            {
                uint16_t *p16;
                uint32_t *p32;
 
                reltype = (*entry & 0xF000) >> 12;
                offs = (*entry & 0x0FFF) + reloc->VirtualAddress;
                switch(reltype)
                {
                    case 1:
                        p16 = MakePtr(uint16_t*, img_base, offs);
                        *p16+= (uint16_t)(delta>>16);
                        break;
                    case 2:
                        p16 = MakePtr(uint16_t*, img_base, offs);
                        *p16+= (uint16_t)delta;
                        break;
                    case 3:
                        p32 = MakePtr(uint32_t*, img_base, offs);
                        *p32+= delta;
                }
                entry++;
            }
            reloc = MakePtr(PIMAGE_BASE_RELOCATION, reloc,reloc->SizeOfBlock);
        }
    };
    return img_base;
};
 
int __fastcall link_image(void *img_base)
{
    static jmp_buf loader_env;
    static recursion = -1;
 
    PIMAGE_DOS_HEADER     dos;
    PIMAGE_NT_HEADERS32   nt;
    int warn = 0;
 
    recursion++;
    if( !recursion )
    {
        if( unlikely(setjmp(loader_env) != 0))
        {
            recursion = -1;
            return 0;
        };
    };
 
    dos = (PIMAGE_DOS_HEADER)img_base;
    nt =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
 
    if(nt->OptionalHeader.DataDirectory[1].Size)
    {
        PIMAGE_IMPORT_DESCRIPTOR imp;
 
        imp = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, img_base,
                      nt->OptionalHeader.DataDirectory[1].VirtualAddress);
 
        while ( imp->Name )
        {
            PIMAGE_DOS_HEADER        expdos;
            PIMAGE_NT_HEADERS32      expnt;
            PIMAGE_EXPORT_DIRECTORY  exp;
            PIMAGE_THUNK_DATA32      thunk;
 
            void       **iat;
            char       *libname;
            uint32_t   *exp_functions;
            uint16_t   *exp_ordinals;
            char      **exp_names;
 
            const module_t *api;
 
            libname=MakePtr(char*,imp->Name, img_base);
 
            DBG("import from %s\n",libname);
 
            api = find_module(libname);
            if(unlikely(api == NULL))
            {
                printf("library %s not found\n", libname);
                longjmp(loader_env, 1);
            }
 
            iat = MakePtr(void**,imp->FirstThunk, img_base);
 
            if(imp->OriginalFirstThunk !=0 )
            {
                thunk = MakePtr(PIMAGE_THUNK_DATA32,imp->OriginalFirstThunk, img_base);
            }
            else
            {
                thunk = MakePtr(PIMAGE_THUNK_DATA32,imp->FirstThunk, img_base);
            };
 
            exp = api->img_exp;
 
            exp_functions = MakePtr(uint32_t*,exp->AddressOfFunctions,api->start);
            exp_ordinals = MakePtr(uint16_t*,  exp->AddressOfNameOrdinals,api->start);
            exp_names = MakePtr(char**, exp->AddressOfNames,api->start);
 
            while ( thunk->u1.AddressOfData != 0 )
            {
                PIMAGE_IMPORT_BY_NAME imp_name;
 
                if (thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG)
                {
//                    ordinal = (*func_list) & 0x7fffffff;
//                   *ImportAddressList = LdrGetExportByOrdinal(ImportedModule->DllBase, Ordinal);
//                    if ((*ImportAddressList) == NULL)
//                    {
//                        DPRINT1("Failed to import #%ld from %wZ\n", Ordinal, &ImportedModule->FullDllName);
//                        RtlpRaiseImportNotFound(NULL, Ordinal, &ImportedModule->FullDllName);
//                        return STATUS_ENTRYPOINT_NOT_FOUND;
//                    }
                }
                else
                {
                    char *export_name;
                    uint16_t   ordinal;
                    void      *function;
                    uint32_t   minn;
                    uint32_t   maxn;
 
                    imp_name = MakePtr(PIMAGE_IMPORT_BY_NAME,
                                  thunk->u1.AddressOfData, img_base);
                    *iat = NULL;
 
                    DBG("import %s", imp_name->Name);
 
                    if(imp_name->Hint < exp->NumberOfNames)
                    {
                        export_name = MakePtr(char*,exp_names[imp_name->Hint],
                                              api->start);
                        if(strcmp(imp_name->Name, export_name) == 0)
                        {
                            ordinal = exp_ordinals[imp_name->Hint];
                            function = MakePtr(void*,exp_functions[ordinal], api->start);
                            if((uint32_t)function >= (uint32_t)exp)
                            {
                                printf("forward %s\n", function);
                                warn=1;
                            }
                            else
                            {
                                DBG(" \t\tat %x\n", function);
                                *iat = function;
                            };
                            thunk++;  // Advance to next thunk
                            iat++;
                            continue;
                        };
                    };
 
 
                    minn = 0;
                    maxn = exp->NumberOfNames - 1;
                    while (minn <= maxn)
                    {
                        int mid;
                        int res;
 
                        mid = (minn + maxn) / 2;
 
                        export_name = MakePtr(char*,exp_names[mid],api->start);
 
                        res = strcmp(export_name, imp_name->Name);
                        if (res == 0)
                        {
                            ordinal  = exp_ordinals[mid];
                            function = MakePtr(void*,exp_functions[ordinal], api->start);
 
                            if((uint32_t)function >= (uint32_t)exp)
                            {
                                printf("forward %s\n", function);
                                warn=1;
                            }
                            else
                            {
                                DBG(" \t\tat %x\n", function);
                                *iat = function;
                            };
                            break;
                        }
                        else if (minn == maxn)
                        {
                            printf(" unresolved %s\n",imp_name->Name);
                            warn=1;
                            break;
                        }
                        else if (res > 0)
                        {
                            maxn = mid - 1;
                        }
                        else
                        {
                            minn = mid + 1;
                        }
                    };
                };
                thunk++;            // Advance to next thunk
                iat++;
            }
            imp++;  // advance to next IMAGE_IMPORT_DESCRIPTOR
        };
    };
 
    recursion--;
 
    if ( !warn )
        return 1;
    else
        return 0;
}
 
void* get_entry_point(void *raw)
{
    PIMAGE_DOS_HEADER     dos;
    PIMAGE_NT_HEADERS32   nt;
 
    dos = (PIMAGE_DOS_HEADER)raw;
    nt =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
 
    return  MakePtr(void*, raw, nt->OptionalHeader.AddressOfEntryPoint);
}
 
 
module_t* load_module(const char *name)
{
    char *path;
    int   len;
 
    len = strlen(name);
 
    dll_path_t *dllpath;
 
    list_for_each_entry(dllpath, &path_list, list)
    {
        PIMAGE_DOS_HEADER        dos;
        PIMAGE_NT_HEADERS32      nt;
        PIMAGE_EXPORT_DIRECTORY  exp;
 
        module_t *module;
        void     *raw_img;
        size_t    raw_size;
        void     *img_base;
 
        path = alloca(len+dllpath->path_len+1);
        memcpy(path, dllpath->path, dllpath->path_len);
 
        memcpy(path+dllpath->path_len, name, len);
        path[len+dllpath->path_len]=0;
 
        raw_img = load_file(path, &raw_size);
        if(raw_img == NULL)
            continue;
 
        if( validate_pe(raw_img, raw_size, 0) == 0)
        {
            printf("invalide module %s\n", path);
            user_free(raw_img);
            continue;
        };
 
        img_base = create_image(raw_img);
        user_free(raw_img);
 
        if( unlikely(img_base == NULL) )
        {
            printf("cannot create image %s\n",path);
            continue;
        };
 
        module = (module_t*)malloc(sizeof(module_t));
 
        if(unlikely(module == NULL))
        {
            printf("%s epic fail: no enough memory\n",__FUNCTION__);
            user_free(img_base);
            return 0;
        }
 
        INIT_LIST_HEAD(&module->list);
 
        module->img_name = strdup(name);
        module->img_path = strdup(path);
        module->start    = img_base;
        module->entry    = get_entry_point(img_base);
        module->refcount = 1;
 
        dos =  (PIMAGE_DOS_HEADER)img_base;
        nt  =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
        exp =  MakePtr(PIMAGE_EXPORT_DIRECTORY, img_base,
                   nt->OptionalHeader.DataDirectory[0].VirtualAddress);
 
        module->end   = MakePtr(uint32_t,img_base, nt->OptionalHeader.SizeOfImage);
 
        module->img_hdr  = nt;
        module->img_sec  = MakePtr(PIMAGE_SECTION_HEADER,nt, sizeof(IMAGE_NT_HEADERS32));
        module->img_exp  = MakePtr(PIMAGE_EXPORT_DIRECTORY, img_base,
                           nt->OptionalHeader.DataDirectory[0].VirtualAddress);
 
        list_add_tail(&module->list, &dll_list);
 
        if( link_image(img_base))
            return module;
        return NULL;
    };
 
    return NULL;
};

Rev 1906	Rev 1907
1	#include	1	#include
2	#include	2	#include
3	#include	3	#include
4	#include	4	#include
5	#include	5	#include
6	#include	6	#include
7	#include	7	#include
8		8
9	#include	9	#include
10		10
11	#include "list.h"	11	#include "list.h"
12	#include "pe.h"	12	#include "pe.h"
13		13
14	#define unlikely(x) __builtin_expect(!!(x), 0)	14	#define unlikely(x) __builtin_expect(!!(x), 0)
15		15
16	//#define DBG(format,...) printf(format,##__VA_ARGS__)	16	//#define DBG(format,...) printf(format,##__VA_ARGS__)
17		17
18	#define DBG(format,...)	18	#define DBG(format,...)
19		19
20		20
21	void __fastcall init_loader(void *libc_image);	21	void __fastcall init_loader(void *libc_image);
22	void* __fastcall create_image(void *raw);	22	void* __fastcall create_image(void *raw);
23	int __fastcall link_image(void *img_base);	23	int __fastcall link_image(void *img_base);
24	int __fastcall do_exec(uint32_t my_app, uint32_t *params);	24	int __fastcall do_exec(uint32_t my_app, uint32_t *params);
25		25
26		26
27	extern char* __appenv;	27	extern char* __appenv;
28	extern int __appenv_size;	28	extern int __appenv_size;
29		29
30	typedef struct tag_module module_t;	30	typedef struct tag_module module_t;
31		31
32	struct app_hdr	32	struct app_hdr
33	{	33	{
34	char banner[8];	34	char banner[8];
35	int version;	35	int version;
36	int start;	36	int start;
37	int iend;	37	int iend;
38	int memsize;	38	int memsize;
39	int stacktop;	39	int stacktop;
40	char *cmdline;	40	char *cmdline;
41	char *path;	41	char *path;
42	};	42	};
43		43
44	struct tag_module	44	struct tag_module
45	{	45	{
46	struct list_head list;	46	struct list_head list;
47		47
48	char *img_name;	48	char *img_name;
49	char *img_path;	49	char *img_path;
50		50
51	uint32_t refcount;	51	uint32_t refcount;
52		52
53	void *start;	53	void *start;
54	uint32_t end;	54	uint32_t end;
55		55
56	void *entry;	56	void *entry;
57		57
58	PIMAGE_NT_HEADERS32 img_hdr;	58	PIMAGE_NT_HEADERS32 img_hdr;
59	PIMAGE_SECTION_HEADER img_sec;	59	PIMAGE_SECTION_HEADER img_sec;
60	PIMAGE_EXPORT_DIRECTORY img_exp;	60	PIMAGE_EXPORT_DIRECTORY img_exp;
61	};	61	};
62		62
63	typedef struct	63	typedef struct
64	{	64	{
65	struct list_head list;	65	struct list_head list;
66	char *path;	66	char *path;
67	int path_len;	67	int path_len;
68	}dll_path_t;	68	}dll_path_t;
69		69
70	module_t* load_module(const char *name);	70	module_t* load_module(const char *name);
71		71
72	LIST_HEAD(dll_list);	72	LIST_HEAD(dll_list);
73	LIST_HEAD(path_list);	73	LIST_HEAD(path_list);
74		74
75	static module_t libc_dll;	75	static module_t libc_dll;
76	static char libc_name[] = "libc.dll";	76	static char libc_name[] = "libc.dll";
77	static char libc_path[] = "/sys/lib/libc.dll";	77	static char libc_path[] = "/sys/lib/libc.dll";
78		78
79	static inline int IsPowerOf2(uint32_t val)	79	static inline int IsPowerOf2(uint32_t val)
80	{	80	{
81	if(val == 0)	81	if(val == 0)
82	return 0;	82	return 0;
83	return (val & (val - 1)) == 0;	83	return (val & (val - 1)) == 0;
84	}	84	}
85		85
86		86
87	int validate_pe(void *raw, size_t raw_size, int is_exec)	87	int validate_pe(void *raw, size_t raw_size, int is_exec)
88	{	88	{
89	PIMAGE_DOS_HEADER dos;	89	PIMAGE_DOS_HEADER dos;
90	PIMAGE_NT_HEADERS32 nt;	90	PIMAGE_NT_HEADERS32 nt;
91		91
92	dos = (PIMAGE_DOS_HEADER)raw;	92	dos = (PIMAGE_DOS_HEADER)raw;
93		93
94	if( !raw \|\| raw_size < sizeof(IMAGE_DOS_HEADER) )	94	if( !raw \|\| raw_size < sizeof(IMAGE_DOS_HEADER) )
95	return 0;	95	return 0;
96		96
97	if( dos->e_magic != IMAGE_DOS_SIGNATURE \|\| dos->e_lfanew <= 0)	97	if( dos->e_magic != IMAGE_DOS_SIGNATURE \|\| dos->e_lfanew <= 0)
98	return 0;	98	return 0;
99		99
100	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);	100	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
101		101
102	if( (uint32_t)nt < (uint32_t)raw)	102	if( (uint32_t)nt < (uint32_t)raw)
103	return 0;	103	return 0;
104		104
105	if(nt->Signature != IMAGE_NT_SIGNATURE)	105	if(nt->Signature != IMAGE_NT_SIGNATURE)
106	return 0;	106	return 0;
107		107
108	if(nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)	108	if(nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
109	return 0;	109	return 0;
110		110
111	if(is_exec && (nt->FileHeader.Characteristics & IMAGE_FILE_DLL))	111	if(is_exec && (nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
112	return 0;	112	return 0;
113		113
114	if(nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)	114	if(nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
115	return 0;	115	return 0;
116		116
117	if( is_exec && nt->OptionalHeader.ImageBase != 0)	117	if( is_exec && nt->OptionalHeader.ImageBase != 0)
118	return 0;	118	return 0;
119		119
120	if(nt->OptionalHeader.SectionAlignment < 4096)	120	if(nt->OptionalHeader.SectionAlignment < 4096)
121	{	121	{
122	if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment)	122	if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment)
123	return 0;	123	return 0;
124	}	124	}
125	else if(nt->OptionalHeader.SectionAlignment < nt->OptionalHeader.FileAlignment)	125	else if(nt->OptionalHeader.SectionAlignment < nt->OptionalHeader.FileAlignment)
126	return 0;	126	return 0;
127		127
128	if(!IsPowerOf2(nt->OptionalHeader.SectionAlignment) \|\|	128	if(!IsPowerOf2(nt->OptionalHeader.SectionAlignment) \|\|
129	!IsPowerOf2(nt->OptionalHeader.FileAlignment))	129	!IsPowerOf2(nt->OptionalHeader.FileAlignment))
130	return 0;	130	return 0;
131		131
132	if(nt->FileHeader.NumberOfSections > 96)	132	if(nt->FileHeader.NumberOfSections > 96)
133	return 0;	133	return 0;
134		134
135	return 1;	135	return 1;
136	}	136	}
137		137
138		138
139	void __fastcall init_loader(void *libc_image)	139	void __fastcall init_loader(void *libc_image)
140	{	140	{
141		141
142	PIMAGE_DOS_HEADER dos;	142	PIMAGE_DOS_HEADER dos;
143	PIMAGE_NT_HEADERS32 nt;	143	PIMAGE_NT_HEADERS32 nt;
144	PIMAGE_EXPORT_DIRECTORY exp;	144	PIMAGE_EXPORT_DIRECTORY exp;
145		145
146	struct app_hdr *header;	146	struct app_hdr *header;
147		147
148	dll_path_t *path;	148	dll_path_t *path;
149	int len;	149	int len;
150	char *p;	150	char *p;
151		151
152	if(__appenv_size)	152	if(__appenv_size)
153	{	153	{
154	char *env;	154	char *env;
155	env = envz_get(__appenv, __appenv_size, "PATH");	155	env = envz_get(__appenv, __appenv_size, "PATH");
156	if( env )	156	if( env )
157	{	157	{
158	while( *env )	158	while( *env )
159	{	159	{
160	p = env;	160	p = env;
161	while(*p)	161	while(*p)
162	{	162	{
163	if( *p == 0x0D)	163	if( *p == 0x0D)
164	break;	164	break;
165	else if( *p == 0x0A)	165	else if( *p == 0x0A)
166	break;	166	break;
167	else if( *p == ':')	167	else if( *p == ':')
168	break;	168	break;
169	p++;	169	p++;
170	};	170	};
171	len = p-env;	171	len = p-env;
172	if(len)	172	if(len)
173	{	173	{
174	char *p1;	174	char *p1;
175		175
176	p1 = (char*)malloc(len+1);	176	p1 = (char*)malloc(len+1);
177	memcpy(p1, env, len);	177	memcpy(p1, env, len);
178	p1[len]=0;	178	p1[len]=0;
179		179
180	path = (dll_path_t*)malloc(sizeof(dll_path_t));	180	path = (dll_path_t*)malloc(sizeof(dll_path_t));
181	INIT_LIST_HEAD(&path->list);	181	INIT_LIST_HEAD(&path->list);
182	path->path = p1;	182	path->path = p1;
183	path->path_len = len;	183	path->path_len = len;
184	DBG("add libraries path %s\n", path->path);	184	DBG("add libraries path %s\n", path->path);
185	list_add_tail(&path->list, &path_list);	185	list_add_tail(&path->list, &path_list);
186	};	186	};
187	if(*p == ':')	187	if(*p == ':')
188	{	188	{
189	env = p+1;	189	env = p+1;
190	continue;	190	continue;
191	}	191	}
192	else break;	192	else break;
193	};	193	};
194	};	194	};
195	};	195	};
196		196
197	header = (struct app_hdr*)NULL;	197	header = (struct app_hdr*)NULL;
198		198
199	len = strrchr(header->path, '/') - header->path+1;	199	len = strrchr(header->path, '/') - header->path+1;
200	p = (char*)malloc(len+1);	200	p = (char*)malloc(len+1);
201	memcpy(p, header->path, len);	201	memcpy(p, header->path, len);
202	p[len]=0;	202	p[len]=0;
203		203
204	path = (dll_path_t*)malloc(sizeof(dll_path_t));	204	path = (dll_path_t*)malloc(sizeof(dll_path_t));
205	INIT_LIST_HEAD(&path->list);	205	INIT_LIST_HEAD(&path->list);
206	path->path = p;	206	path->path = p;
207	path->path_len = len;	207	path->path_len = len;
208	DBG("add libraries path %s\n", path->path);	208	DBG("add libraries path %s\n", path->path);
209	list_add_tail(&path->list, &path_list);	209	list_add_tail(&path->list, &path_list);
210		210
211		211
212	#if 0	212	#if 0
213	path = (dll_path_t*)malloc(sizeof(dll_path_t));	213	path = (dll_path_t*)malloc(sizeof(dll_path_t));
214	INIT_LIST_HEAD(&path->list);	214	INIT_LIST_HEAD(&path->list);
215	path->path = "/sys/lib/";	215	path->path = "/sys/lib/";
216	path->path_len = 9; /* FIXME */	216	path->path_len = 9; /* FIXME */
217	DBG("add libraries path %s\n", path->path);	217	DBG("add libraries path %s\n", path->path);
218	list_add_tail(&path->list, &path_list);	218	list_add_tail(&path->list, &path_list);
219	#endif	219	#endif
220		220
221	INIT_LIST_HEAD(&libc_dll.list);	221	INIT_LIST_HEAD(&libc_dll.list);
222		222
223	libc_dll.img_name = libc_name;	223	libc_dll.img_name = libc_name;
224	libc_dll.img_path = libc_path;	224	libc_dll.img_path = libc_path;
225		225
226	libc_dll.refcount = 1;	226	libc_dll.refcount = 1;
227		227
228	dos = (PIMAGE_DOS_HEADER)libc_image;	228	dos = (PIMAGE_DOS_HEADER)libc_image;
229	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);	229	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
230	exp = MakePtr(PIMAGE_EXPORT_DIRECTORY, libc_image,	230	exp = MakePtr(PIMAGE_EXPORT_DIRECTORY, libc_image,
231	nt->OptionalHeader.DataDirectory[0].VirtualAddress);	231	nt->OptionalHeader.DataDirectory[0].VirtualAddress);
232		232
233	libc_dll.start = libc_image;	233	libc_dll.start = libc_image;
234	libc_dll.end = MakePtr(uint32_t,libc_image, nt->OptionalHeader.SizeOfImage);	234	libc_dll.end = MakePtr(uint32_t,libc_image, nt->OptionalHeader.SizeOfImage);
235		235
236	libc_dll.img_hdr = nt;	236	libc_dll.img_hdr = nt;
237	libc_dll.img_sec = MakePtr(PIMAGE_SECTION_HEADER,nt, sizeof(IMAGE_NT_HEADERS32));	237	libc_dll.img_sec = MakePtr(PIMAGE_SECTION_HEADER,nt, sizeof(IMAGE_NT_HEADERS32));
238	libc_dll.img_exp = MakePtr(PIMAGE_EXPORT_DIRECTORY,libc_image,	238	libc_dll.img_exp = MakePtr(PIMAGE_EXPORT_DIRECTORY,libc_image,
239	nt->OptionalHeader.DataDirectory[0].VirtualAddress);	239	nt->OptionalHeader.DataDirectory[0].VirtualAddress);
240		240
241	list_add_tail(&libc_dll.list, &dll_list);	241	list_add_tail(&libc_dll.list, &dll_list);
242	};	242	};
243		243
244	const module_t* find_module(const char *name)	244	const module_t* find_module(const char *name)
245	{	245	{
246	module_t* mod;	246	module_t* mod;
247		247
248	list_for_each_entry(mod, &dll_list, list)	248	list_for_each_entry(mod, &dll_list, list)
249	{	249	{
250	if( !strncmp(name, mod->img_name, 16))	250	if( !strncmp(name, mod->img_name, 16))
251	return mod;	251	return mod;
252	};	252	};
253		253
254	return load_module(name);	254	return load_module(name);
255	};	255	};
256		256
257	static inline void sec_copy(void dst, void src, size_t len)	257	static inline void sec_copy(void dst, void src, size_t len)
258	{	258	{
259	__asm__ __volatile__ (	259	__asm__ __volatile__ (
260	"shrl $2, %%ecx \n\t"	260	"shrl $2, %%ecx \n\t"
261	"rep movsl"	261	"rep movsl"
262	:	262	:
263	:"c"(len),"S"(src),"D"(dst)	263	:"c"(len),"S"(src),"D"(dst)
264	:"cc");	264	:"cc");
265	__asm__ __volatile__ (	265	__asm__ __volatile__ (
266	""	266	""
267	:::"ecx","esi","edi");	267	:::"ecx","esi","edi");
268	};	268	};
269		269
270	static inline void *user_alloc(size_t size)	270	static inline void *user_alloc(size_t size)
271	{	271	{
272	void *val;	272	void *val;
273	__asm__ __volatile__(	273	__asm__ __volatile__(
274	"int $0x40"	274	"int $0x40"
275	:"=eax"(val)	275	:"=eax"(val)
276	:"a"(68),"b"(12),"c"(size));	276	:"a"(68),"b"(12),"c"(size));
277	return val;	277	return val;
278	}	278	}
279		279
280	void* __fastcall create_image(void *raw)	280	void* __fastcall create_image(void *raw)
281	{	281	{
282	PIMAGE_DOS_HEADER dos;	282	PIMAGE_DOS_HEADER dos;
283	PIMAGE_NT_HEADERS32 nt;	283	PIMAGE_NT_HEADERS32 nt;
284	PIMAGE_SECTION_HEADER img_sec;	284	PIMAGE_SECTION_HEADER img_sec;
285		285
286	void *img_base;	286	void *img_base;
287	uint32_t sec_align;	287	uint32_t sec_align;
288	int i;	288	int i;
289		289
290	dos = (PIMAGE_DOS_HEADER)raw;	290	dos = (PIMAGE_DOS_HEADER)raw;
291	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);	291	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
292		292
293	img_base = user_alloc(nt->OptionalHeader.SizeOfImage);	293	img_base = user_alloc(nt->OptionalHeader.SizeOfImage);
294		294
295	if(unlikely(img_base == NULL))	295	if(unlikely(img_base == NULL))
296	return 0;	296	return 0;
297		297
298	sec_copy(img_base, raw, nt->OptionalHeader.SizeOfHeaders);	298	sec_copy(img_base, raw, nt->OptionalHeader.SizeOfHeaders);
299		299
300	img_sec = MakePtr(PIMAGE_SECTION_HEADER, nt, sizeof(IMAGE_NT_HEADERS32));	300	img_sec = MakePtr(PIMAGE_SECTION_HEADER, nt, sizeof(IMAGE_NT_HEADERS32));
301		301
302	sec_align = nt->OptionalHeader.SectionAlignment;	302	sec_align = nt->OptionalHeader.SectionAlignment;
303		303
304	for(i=0; i< nt->FileHeader.NumberOfSections; i++)	304	for(i=0; i< nt->FileHeader.NumberOfSections; i++)
305	{	305	{
306	void *src_ptr;	306	void *src_ptr;
307	void *dest_ptr;	307	void *dest_ptr;
308	size_t sec_size;	308	size_t sec_size;
309		309
310	if ( img_sec->SizeOfRawData && img_sec->PointerToRawData )	310	if ( img_sec->SizeOfRawData && img_sec->PointerToRawData )
311	{	311	{
312	src_ptr = MakePtr(void*, raw, img_sec->PointerToRawData);	312	src_ptr = MakePtr(void*, raw, img_sec->PointerToRawData);
313	dest_ptr = MakePtr(void*, img_base, img_sec->VirtualAddress);	313	dest_ptr = MakePtr(void*, img_base, img_sec->VirtualAddress);
314	sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData);	314	sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData);
315	};	315	};
316		316
317	img_sec++;	317	img_sec++;
318	};	318	};
319		319
320	if(nt->OptionalHeader.DataDirectory[5].Size)	320	if(nt->OptionalHeader.DataDirectory[5].Size)
321	{	321	{
322	PIMAGE_BASE_RELOCATION reloc;	322	PIMAGE_BASE_RELOCATION reloc;
323		323
324	uint32_t delta = (uint32_t)img_base - nt->OptionalHeader.ImageBase;	324	uint32_t delta = (uint32_t)img_base - nt->OptionalHeader.ImageBase;
325		325
326	reloc = MakePtr(PIMAGE_BASE_RELOCATION, img_base,	326	reloc = MakePtr(PIMAGE_BASE_RELOCATION, img_base,
327	nt->OptionalHeader.DataDirectory[5].VirtualAddress);	327	nt->OptionalHeader.DataDirectory[5].VirtualAddress);
328		328
329	while ( reloc->SizeOfBlock != 0 )	329	while ( reloc->SizeOfBlock != 0 )
330	{	330	{
331	uint32_t cnt;	331	uint32_t cnt;
332	uint16_t *entry;	332	uint16_t *entry;
333	uint16_t reltype;	333	uint16_t reltype;
334	uint32_t offs;	334	uint32_t offs;
335		335
336	cnt = (reloc->SizeOfBlock - sizeof(*reloc))/sizeof(uint16_t);	336	cnt = (reloc->SizeOfBlock - sizeof(*reloc))/sizeof(uint16_t);
337	entry = MakePtr( uint16_t, reloc, sizeof(reloc) );	337	entry = MakePtr( uint16_t, reloc, sizeof(reloc) );
338		338
339	for ( i=0; i < cnt; i++ )	339	for ( i=0; i < cnt; i++ )
340	{	340	{
341	uint16_t *p16;	341	uint16_t *p16;
342	uint32_t *p32;	342	uint32_t *p32;
343		343
344	reltype = (*entry & 0xF000) >> 12;	344	reltype = (*entry & 0xF000) >> 12;
345	offs = (*entry & 0x0FFF) + reloc->VirtualAddress;	345	offs = (*entry & 0x0FFF) + reloc->VirtualAddress;
346	switch(reltype)	346	switch(reltype)
347	{	347	{
348	case 1:	348	case 1:
349	p16 = MakePtr(uint16_t*, img_base, offs);	349	p16 = MakePtr(uint16_t*, img_base, offs);
350	*p16+= (uint16_t)(delta>>16);	350	*p16+= (uint16_t)(delta>>16);
351	break;	351	break;
352	case 2:	352	case 2:
353	p16 = MakePtr(uint16_t*, img_base, offs);	353	p16 = MakePtr(uint16_t*, img_base, offs);
354	*p16+= (uint16_t)delta;	354	*p16+= (uint16_t)delta;
355	break;	355	break;
356	case 3:	356	case 3:
357	p32 = MakePtr(uint32_t*, img_base, offs);	357	p32 = MakePtr(uint32_t*, img_base, offs);
358	*p32+= delta;	358	*p32+= delta;
359	}	359	}
360	entry++;	360	entry++;
361	}	361	}
362	reloc = MakePtr(PIMAGE_BASE_RELOCATION, reloc,reloc->SizeOfBlock);	362	reloc = MakePtr(PIMAGE_BASE_RELOCATION, reloc,reloc->SizeOfBlock);
363	}	363	}
364	};	364	};
365	return img_base;	365	return img_base;
366	};	366	};
367		367
368	int __fastcall link_image(void *img_base)	368	int __fastcall link_image(void *img_base)
369	{	369	{
370	static jmp_buf loader_env;	370	static jmp_buf loader_env;
371	static recursion = -1;	371	static recursion = -1;
372		372
373	PIMAGE_DOS_HEADER dos;	373	PIMAGE_DOS_HEADER dos;
374	PIMAGE_NT_HEADERS32 nt;	374	PIMAGE_NT_HEADERS32 nt;
375	int warn = 0;	375	int warn = 0;
376		376
377	recursion++;	377	recursion++;
378	if( !recursion )	378	if( !recursion )
379	{	379	{
380	if( unlikely(setjmp(loader_env) != 0))	380	if( unlikely(setjmp(loader_env) != 0))
381	{	381	{
382	recursion = -1;	382	recursion = -1;
383	return 0;	383	return 0;
384	};	384	};
385	};	385	};
386		386
387	dos = (PIMAGE_DOS_HEADER)img_base;	387	dos = (PIMAGE_DOS_HEADER)img_base;
388	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);	388	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
389		389
390	if(nt->OptionalHeader.DataDirectory[1].Size)	390	if(nt->OptionalHeader.DataDirectory[1].Size)
391	{	391	{
392	PIMAGE_IMPORT_DESCRIPTOR imp;	392	PIMAGE_IMPORT_DESCRIPTOR imp;
393		393
394	imp = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, img_base,	394	imp = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, img_base,
395	nt->OptionalHeader.DataDirectory[1].VirtualAddress);	395	nt->OptionalHeader.DataDirectory[1].VirtualAddress);
396		396
397	while ( imp->Name )	397	while ( imp->Name )
398	{	398	{
399	PIMAGE_DOS_HEADER expdos;	399	PIMAGE_DOS_HEADER expdos;
400	PIMAGE_NT_HEADERS32 expnt;	400	PIMAGE_NT_HEADERS32 expnt;
401	PIMAGE_EXPORT_DIRECTORY exp;	401	PIMAGE_EXPORT_DIRECTORY exp;
402	PIMAGE_THUNK_DATA32 thunk;	402	PIMAGE_THUNK_DATA32 thunk;
403		403
404	void **iat;	404	void **iat;
405	char *libname;	405	char *libname;
406	uint32_t *exp_functions;	406	uint32_t *exp_functions;
407	uint16_t *exp_ordinals;	407	uint16_t *exp_ordinals;
408	char **exp_names;	408	char **exp_names;
409		409
410	const module_t *api;	410	const module_t *api;
411		411
412	libname=MakePtr(char*,imp->Name, img_base);	412	libname=MakePtr(char*,imp->Name, img_base);
413		413
414	DBG("import from %s\n",libname);	414	DBG("import from %s\n",libname);
415		415
416	api = find_module(libname);	416	api = find_module(libname);
417	if(unlikely(api == NULL))	417	if(unlikely(api == NULL))
418	{	418	{
419	printf("library %s not found\n", libname);	419	printf("library %s not found\n", libname);
420	longjmp(loader_env, 1);	420	longjmp(loader_env, 1);
421	}	421	}
422		422
423	iat = MakePtr(void**,imp->FirstThunk, img_base);	423	iat = MakePtr(void**,imp->FirstThunk, img_base);
424		424
425	if(imp->OriginalFirstThunk !=0 )	425	if(imp->OriginalFirstThunk !=0 )
426	{	426	{
427	thunk = MakePtr(PIMAGE_THUNK_DATA32,imp->OriginalFirstThunk, img_base);	427	thunk = MakePtr(PIMAGE_THUNK_DATA32,imp->OriginalFirstThunk, img_base);
428	}	428	}
429	else	429	else
430	{	430	{
431	thunk = MakePtr(PIMAGE_THUNK_DATA32,imp->FirstThunk, img_base);	431	thunk = MakePtr(PIMAGE_THUNK_DATA32,imp->FirstThunk, img_base);
432	};	432	};
433		433
434	exp = api->img_exp;	434	exp = api->img_exp;
435		435
436	exp_functions = MakePtr(uint32_t*,exp->AddressOfFunctions,api->start);	436	exp_functions = MakePtr(uint32_t*,exp->AddressOfFunctions,api->start);
437	exp_ordinals = MakePtr(uint16_t*, exp->AddressOfNameOrdinals,api->start);	437	exp_ordinals = MakePtr(uint16_t*, exp->AddressOfNameOrdinals,api->start);
438	exp_names = MakePtr(char**, exp->AddressOfNames,api->start);	438	exp_names = MakePtr(char**, exp->AddressOfNames,api->start);
439		439
440	while ( thunk->u1.AddressOfData != 0 )	440	while ( thunk->u1.AddressOfData != 0 )
441	{	441	{
442	PIMAGE_IMPORT_BY_NAME imp_name;	442	PIMAGE_IMPORT_BY_NAME imp_name;
443		443
444	if (thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG)	444	if (thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG)
445	{	445	{
446	// ordinal = (*func_list) & 0x7fffffff;	446	// ordinal = (*func_list) & 0x7fffffff;
447	// *ImportAddressList = LdrGetExportByOrdinal(ImportedModule->DllBase, Ordinal);	447	// *ImportAddressList = LdrGetExportByOrdinal(ImportedModule->DllBase, Ordinal);
448	// if ((*ImportAddressList) == NULL)	448	// if ((*ImportAddressList) == NULL)
449	// {	449	// {
450	// DPRINT1("Failed to import #%ld from %wZ\n", Ordinal, &ImportedModule->FullDllName);	450	// DPRINT1("Failed to import #%ld from %wZ\n", Ordinal, &ImportedModule->FullDllName);
451	// RtlpRaiseImportNotFound(NULL, Ordinal, &ImportedModule->FullDllName);	451	// RtlpRaiseImportNotFound(NULL, Ordinal, &ImportedModule->FullDllName);
452	// return STATUS_ENTRYPOINT_NOT_FOUND;	452	// return STATUS_ENTRYPOINT_NOT_FOUND;
453	// }	453	// }
454	}	454	}
455	else	455	else
456	{	456	{
457	char *export_name;	457	char *export_name;
458	uint16_t ordinal;	458	uint16_t ordinal;
459	void *function;	459	void *function;
460	uint32_t minn;	460	uint32_t minn;
461	uint32_t maxn;	461	uint32_t maxn;
462		462
463	imp_name = MakePtr(PIMAGE_IMPORT_BY_NAME,	463	imp_name = MakePtr(PIMAGE_IMPORT_BY_NAME,
464	thunk->u1.AddressOfData, img_base);	464	thunk->u1.AddressOfData, img_base);
465	*iat = NULL;	465	*iat = NULL;
466		466
467	DBG("import %s", imp_name->Name);	467	DBG("import %s", imp_name->Name);
468		468
469	if(imp_name->Hint < exp->NumberOfNames)	469	if(imp_name->Hint < exp->NumberOfNames)
470	{	470	{
471	export_name = MakePtr(char*,exp_names[imp_name->Hint],	471	export_name = MakePtr(char*,exp_names[imp_name->Hint],
472	api->start);	472	api->start);
473	if(strcmp(imp_name->Name, export_name) == 0)	473	if(strcmp(imp_name->Name, export_name) == 0)
474	{	474	{
475	ordinal = exp_ordinals[imp_name->Hint];	475	ordinal = exp_ordinals[imp_name->Hint];
476	function = MakePtr(void*,exp_functions[ordinal], api->start);	476	function = MakePtr(void*,exp_functions[ordinal], api->start);
477	if((uint32_t)function >= (uint32_t)exp)	477	if((uint32_t)function >= (uint32_t)exp)
478	{	478	{
479	printf("forward %s\n", function);	479	printf("forward %s\n", function);
480	warn=1;	480	warn=1;
481	}	481	}
482	else	482	else
483	{	483	{
484	DBG(" \t\tat %x\n", function);	484	DBG(" \t\tat %x\n", function);
485	*iat = function;	485	*iat = function;
486	};	486	};
487	thunk++; // Advance to next thunk	487	thunk++; // Advance to next thunk
488	iat++;	488	iat++;
489	continue;	489	continue;
490	};	490	};
491	};	491	};
492		492
493		493
494	minn = 0;	494	minn = 0;
495	maxn = exp->NumberOfNames - 1;	495	maxn = exp->NumberOfNames - 1;
496	while (minn <= maxn)	496	while (minn <= maxn)
497	{	497	{
498	int mid;	498	int mid;
499	int res;	499	int res;
500		500

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/newlib/pe/loader.c – Rev 1906 → 1907