Subversion Repositories Kolibri OS

#pragma pack(push,4)

typedef struct

{

  char     app_name[16];

  addr_t   fpu_state;                       /*      +16       */

  count_t  ev_count;                        /*      +20       */

  addr_t   fpu_handler;                     /*      +24       */

  addr_t   sse_handler;                     /*      +28       */

  addr_t   pl0_stack;                       /*      +32       */

  addr_t   heap_base;                       /*      +36       */

  addr_t   heap_top;                        /*      +40       */

  addr_t   cursor;                          /*      +44       */

  addr_t   fd_ev;                           /*      +48       */

  addr_t   bk_ev;                           /*      +52       */

  addr_t   fd_obj;                          /*      +56       */

  addr_t   bk_obj;                          /*      +60       */

  addr_t   saved_esp;                       /*      +64       */

  addr_t   io_map[2];                       /*      +68       */

  u32_t    dbg_state;                       /*      +76       */

  char    *cur_dir;                         /*      +80       */

  count_t  wait_timeout;                    /*      +84       */

  addr_t   saved_esp0;                      /*      +88       */

  link_t   dll_list;                        /*      +92       */

  u32_t    reserved0[7];                    /*      +100   db 28 dup(?)  */

  addr_t   wnd_shape;                       /*      +128      */

  u32_t    wnd_shape_scale;                 /*      +132      */

  u32_t    reserved1;                       /*      +136      */

  size_t   mem_size;                        /*      +140      */

}appdata_t;

#pragma pack(pop)

extern appdata_t *current_slot;

bool link_pe(addr_t img_base);

dll_t core_dll;

    dll_slab = slab_cache_create(sizeof(dll_t), 16,NULL,NULL,SLAB_CACHE_MAGDEFERRED);

int sys_exec(char *path, char *cmdline, u32_t flags)

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    img_size  =  nt->OptionalHeader.SizeOfImage;

#define  master_tab    (page_tabs+ (page_tabs>>10))

typedef struct

{

    u32_t edi;

    u32_t esi;

    u32_t ebp;

    u32_t esp;

    u32_t ebx;

    u32_t edx;

    u32_t ecx;

    u32_t eax;

    u32_t eip;

    u32_t cs;

    u32_t eflags;

    u32_t pe_sp;

    u32_t pe_ss;

}thr_stack_t;

#define EFL_IF      0x0200

#define EFL_IOPL1   0x1000

    current_slot->mem_size  = img_size;

    list_initialize(¤t_slot->dll_list);

    img_pages = img_size >> 12;

    for(i = 0; i < img_pages; i++)

    {

        addr_t page = core_alloc(0);

    }

    addr_t stack_page = ((addr_t)ex_stack-OS_BASE) & ~4095;

    ((u32_t*)page_tabs)[0x7FFFF000>>12] = stack_page | 7;

    init_user_heap();

    if (! link_pe(0))

    {

        DBG("\nunresolved imports\nexit\n");

        __asm__ __volatile__ (

        "int $0x40"::"a"(-1));

    };

//    __asm__ __volatile__ (

//    "xchgw %bx, %bx");

    addr_t entry = nt->OptionalHeader.AddressOfEntryPoint +

                   nt->OptionalHeader.ImageBase;

    thr_stack->edi = 0;

    thr_stack->esi = 0;

    thr_stack->ebp = 0;

    thr_stack->ebx = 0;

    thr_stack->edx = 0;

    thr_stack->ecx = 0;

    thr_stack->eax = 0;

    thr_stack->eip = entry;

    thr_stack->cs  = 0x1b;

    thr_stack->eflags = EFL_IOPL3 | EFL_IF;

    thr_stack->pe_sp = 0x7FFFF000 + ((u32_t)ex_stack & 0xFFF);

    thr_stack->pe_ss = 0x23;

};

void  __stdcall user_free(void *mem) asm("user_free");

dll_t* __fastcall load_dll(const char *path)

{

    PIMAGE_DOS_HEADER        dos;

    PIMAGE_NT_HEADERS32      nt;

    md_t    *img_md;

    size_t   img_size;

    addr_t   img_base;

    count_t  img_pages;

    size_t   raw_size = 0;

    void    *raw;

    DBG("\nload dll %s", path);

    raw = load_file(path, &raw_size);

    DBG("  raw = %x\n", raw);

    if( ! raw)

    {

        DBG("file not found: %s\n", path);

        return NULL;

    };

    if( ! validate_pe(raw, raw_size) )

    {

        DBG("invalid pe file %s\n", path);

        mem_free(raw);

        return NULL;

    }

    dos = (PIMAGE_DOS_HEADER)raw;

    nt =  MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);

    img_size  =  nt->OptionalHeader.SizeOfImage;

    img_base = (addr_t)user_alloc(img_size);

    if( !img_base)

    {

        mem_free(raw);

        return NULL;

    };

    dll_t *dll = (dll_t*)slab_alloc(dll_slab,0);         /* FIXME check */

    if( !dll)

    {

        mem_free(raw);

        user_free((void*)img_base);

        return NULL;

    };

    create_image(img_base, (addr_t)raw);

    mem_free(raw);

    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);

    dll->img_base = img_base;

    dll->img_size = nt->OptionalHeader.SizeOfImage;

    dll->img_md   = NULL;

    dll->img_hdr  = nt;

    dll->img_sec  = MakePtr(PIMAGE_SECTION_HEADER,nt, sizeof(IMAGE_NT_HEADERS32));

    dll->img_exp  = MakePtr(PIMAGE_EXPORT_DIRECTORY,img_base,

                            nt->OptionalHeader.DataDirectory[0].VirtualAddress);

    dll->img_name = strupr(MakePtr(char*, img_base, exp->Name));

    list_insert(¤t_slot->dll_list, &dll->link);

    return dll;

};

bool link_pe(addr_t img_base)

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    int warn = 0;

/* assumed that image is valid */

    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 ( 1 )

        {

            PIMAGE_THUNK_DATA32     thunk;

            PIMAGE_DOS_HEADER       expdos;

            PIMAGE_NT_HEADERS32     expnt;

            PIMAGE_EXPORT_DIRECTORY exp;

            u32_t   *iat;

            char    *libname;

            addr_t  *functions;

            u16_t   *ordinals;

            char   **funcname;

            dll_t   *exp_dll;

            if ( (imp->TimeDateStamp==0 ) && (imp->Name==0) )

                break;

            libname=MakePtr(char*,imp->Name, img_base);

            DBG("import from %s\n",libname);

            if(exp_dll != NULL)

            {

                DBG("find %s\n", exp_dll->img_name);

            }

            else

            {

                int len = strlen(libname)+1;

                memcpy(path, "/sys/lib/",9);

                memcpy(&path[9],libname,len);

                exp_dll = load_dll(path);

                if( !exp_dll)

                {

                    DBG("can't load %s\n", path);

                    return false;

                };

            }

            exp = exp_dll->img_exp;

            functions = MakePtr(DWORD*,exp->AddressOfFunctions,exp_dll->img_base);

            ordinals = MakePtr(WORD*,  exp->AddressOfNameOrdinals,exp_dll->img_base);

            funcname = MakePtr(char**, exp->AddressOfNames,exp_dll->img_base);

            thunk = MakePtr(PIMAGE_THUNK_DATA32,

                            imp->Characteristics, img_base);

            iat= MakePtr(DWORD*,imp->FirstThunk, img_base);

            while ( 1 ) // Loop forever (or until we break out)

            {

                PIMAGE_IMPORT_BY_NAME ord;

                addr_t addr;

                if ( thunk->u1.AddressOfData == 0 )

                    break;

                if ( thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG )

                {

        //  printf("  %4u\n", thunk->u1.Ordinal & 0xFFFF);

                    break;

                }

                else

                {

                    ord = MakePtr(PIMAGE_IMPORT_BY_NAME,

                                  thunk->u1.AddressOfData, img_base);

                    *iat=0;

                    DBG("import %s", ord->Name);

                    if(strncmp(ord->Name,

                       MakePtr(char*,funcname[ord->Hint],exp_dll->img_base),32))

                    {

                        int ind;

                        char **names=funcname;

                        for(names = funcname,ind = 0;

                            ind < exp->NumberOfNames; names++,ind++)

                        {

                            if(!strncmp(ord->Name,MakePtr(char*,*names,exp_dll->img_base),32))

                            {

                                u16_t ordinal;

                                ordinal = ordinals[ind];

                                DBG(" \t\tat %x\n", functions[ordinal] + exp_dll->img_base);

                                *iat = functions[ordinal] + exp_dll->img_base;

                                break;

                            };

                        };

                        if(ind == exp->NumberOfNames)

                        {

                            DBG(" unresolved import %s\n",ord->Name);

                            warn=1;

                        };

                    }

                    else

                    {