WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/newlib/libc/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    init_loader(void *libc_image);
void*   create_image(void *raw);
int     link_image(void *img_base, PIMAGE_IMPORT_DESCRIPTOR imp);
void*   load_library(const char *name);
 
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;
    int    reserved;
    void  *__idata_start;
    void  *__idata_end;
    void  (*main)(int argc, char **argv, char **envp);
};
 
struct tag_module
{
    struct list_head list;
 
    char       *img_name;
    char       *img_path;
 
    uint32_t    refcount;
 
    char       *start;
    char       *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;
 
 
LIST_HEAD(path_list);
 
static module_t libc_dll;
static char libc_name[] = "libc.dll";
static char libc_path[] = "/KolibriOS/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 init_loader(void *libc_image)
{
 
    PIMAGE_DOS_HEADER        dos;
    PIMAGE_NT_HEADERS32      nt;
    PIMAGE_EXPORT_DIRECTORY  exp;
 
    struct app_hdr  *header = NULL;
    dll_path_t      *path;
    int             len;
    char            *p;
 
#if 0
 
    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;
            };
        };
    };
#endif
 
    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);
 
 
    path = (dll_path_t*)malloc(sizeof(dll_path_t));
    INIT_LIST_HEAD(&path->list);
    path->path = "/kolibrios/lib/";
    path->path_len = 15;                           /* FIXME */
    DBG("add libraries path %s\n", path->path);
    list_add_tail(&path->list, &path_list);
 
    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(char*,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);
 
};
 
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");
};
 
 
void* 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 = _ksys_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 link_image(void *img_base, PIMAGE_IMPORT_DESCRIPTOR imp)
{
    static jmp_buf loader_env;
    static int recursion = -1;
    int warn = 0;
 
    recursion++;
    if( !recursion )
    {
        if( unlikely(setjmp(loader_env) != 0))
        {
            recursion = -1;
            return 0;
        };
    };
 
    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 = load_library(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;
}
 
static void send_dbg_msg(void *msg)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(69),
      "b"(10),
      "S"(msg));
};
 
 
int link_app()
{
    struct app_hdr *header = NULL;
    PIMAGE_IMPORT_DESCRIPTOR imp;
 
    imp = (PIMAGE_IMPORT_DESCRIPTOR)header->__idata_start;
 
    if(link_image(NULL, imp))
    {
 
#ifdef DEBUG_INFO
        struct
        {
            void     *start;
            uint32_t  end;
            char      name[24];
        } dbg_msg;
 
        module_t *mod = &libc_dll;
 
        do
        {
            printf("%s %x - %x\n",
                   mod->img_name, mod->start, mod->end);
 
//            asm volatile("int3");
 
            dbg_msg.start = mod->start;
            dbg_msg.end   = mod->end;
            strcpy(dbg_msg.name, mod->img_name);
            send_dbg_msg(&dbg_msg);
            mod = (module_t*)mod->list.next;
        }while(mod != &libc_dll);
#endif
 
        return 1;
    };
 
    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);
};
 
 
void *get_proc_address(void *handle, const char *proc_name)
{
 
    module_t *module = handle;
    PIMAGE_DOS_HEADER        expdos;
    PIMAGE_NT_HEADERS32      expnt;
    PIMAGE_EXPORT_DIRECTORY  exp;
 
    uint32_t   *exp_functions;
    uint16_t   *exp_ordinals;
    char      **exp_names;
 
    int minn, maxn;
    char *export_name;
    uint16_t   ordinal;
    void *function=NULL;
 
    exp = module->img_exp;
 
    exp_functions = MakePtr(uint32_t*,exp->AddressOfFunctions,module->start);
    exp_ordinals = MakePtr(uint16_t*,  exp->AddressOfNameOrdinals,module->start);
    exp_names = MakePtr(char**, exp->AddressOfNames,module->start);
 
    minn = 0;
    maxn = exp->NumberOfNames - 1;
    while (minn <= maxn)
    {
        int mid;
        int res;
 
        mid = (minn + maxn) / 2;
 
        export_name = MakePtr(char*,exp_names[mid],module->start);
 
        res = strcmp(export_name, proc_name);
        if (res == 0)
        {
            ordinal  = exp_ordinals[mid];
            function = MakePtr(void*,exp_functions[ordinal], module->start);
 
            if((uint32_t)function >= (uint32_t)exp)
            {
                printf("forward %s\n", function);
            }
            else
            {
                DBG(" \t\tat %x\n", function);
            };
            break;
        }
        else if (minn == maxn)
        {
            DBG(" unresolved %s\n",proc_name);
            break;
        }
        else if (res > 0)
        {
            maxn = mid - 1;
        }
        else
        {
            minn = mid + 1;
        }
    };
 
    return function;
};
 
static void *load_lib_internal(const char *path)
{
    PIMAGE_DOS_HEADER        dos;
    PIMAGE_NT_HEADERS32      nt;
    PIMAGE_EXPORT_DIRECTORY  exp;
 
    ksys_ufile_t   uf;
    void     *raw_img;
    size_t    raw_size;
    void     *img_base = NULL;
 
    uf = _ksys_load_file(path);
    raw_img  = uf.data;
    raw_size = uf.size;
 
    if(raw_img == NULL)
        return NULL;
 
    if( validate_pe(raw_img, raw_size, 0) == 0)
    {
        printf("invalide module %s\n", path);
        _ksys_free(raw_img);
        return NULL;
    };
 
    img_base = create_image(raw_img);
    _ksys_free(raw_img);
 
    if( unlikely(img_base == NULL) )
        printf("cannot create image %s\n",path);
 
    return img_base;
}
 
void* load_library(const char *name)
{
    PIMAGE_DOS_HEADER        dos;
    PIMAGE_NT_HEADERS32      nt;
    PIMAGE_EXPORT_DIRECTORY  exp;
 
    module_t    *module, *mod = &libc_dll;
    dll_path_t  *dllpath;
    char        *path;
    int          len;
    char        *libname, *tmp;
    void        *img_base;
 
 
/*  check for already loaded libraries  */
 
    tmp = strrchr(name, '/');
    libname = path = tmp != NULL ? tmp+1 : (char*)name;
 
//    printf("path %s\n", path);
 
    do
    {
        if( !strncmp(path, mod->img_name, 16))
            return mod;
        mod = (module_t*)mod->list.next;
    }while(mod != &libc_dll);
 
    if(name[0] == '/')
    {
        path = (char*)name;
        img_base = load_lib_internal(path);
    }
    else
    {
        len = strlen(libname);
        list_for_each_entry(dllpath, &path_list, list)
        {
            path = alloca(len+dllpath->path_len+1);
            memcpy(path, dllpath->path, dllpath->path_len);
 
            memcpy(path+dllpath->path_len, libname, len);
            path[len+dllpath->path_len]=0;
 
//            printf("%s\n", path);
 
            img_base = load_lib_internal(path);
 
            if( unlikely(img_base == NULL) )
                continue;
        };
    }
 
    if( unlikely(img_base == NULL) )
    {
        printf("unable to load %s\n", name);
        return 0;
    };
 
    module = malloc(sizeof(module_t));
 
    if(unlikely(module == NULL))
    {
        printf("%s epic fail: no enough memory\n",__FUNCTION__);
        goto err1;
    }
 
    INIT_LIST_HEAD(&module->list);
 
    module->img_name = strdup(libname);
    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(char*,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, &libc_dll.list);
 
    if(nt->OptionalHeader.DataDirectory[1].Size)
    {
        PIMAGE_IMPORT_DESCRIPTOR imp;
        int (*dll_startup)(module_t *mod, uint32_t reason);
 
        imp = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, img_base,
                    nt->OptionalHeader.DataDirectory[1].VirtualAddress);
 
        if(link_image(img_base, imp) == 0)
            goto err2;
 
        dll_startup = get_proc_address(module, "DllStartup");
        if( dll_startup )
        {
            if( 0 == dll_startup(module, 1))
                goto err2;
        }
    };
 
//    printf("module %s %p - %p\n", name, module->start, module->end);
 
    return module;
 
err2:
    list_del(&module->list);
    free(module->img_name);
    free(module->img_path);
    free(module);
err1:
    _ksys_free(img_base);
    return NULL;
};
 
void enumerate_libraries(int (*callback)(void *handle, const char* name,
                                         uint32_t base, uint32_t size, void *user_data),
                         void *user_data)
{
    module_t *mod = &libc_dll;
 
    do
    {
        if(0 == callback(mod, mod->img_name, (uint32_t)mod->start,
                         mod->end - mod->start, user_data))
            break;
        mod = (module_t*)mod->list.next;
    }while(mod != &libc_dll);
}

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

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/newlib/libc/pe/loader.c – Rev 6536 → 9874