Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include 

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_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       */

  char    *cur_dir;                         /*      +80       */

  count_t  wait_timeout;                    /*      +84       */

  addr_t   saved_esp0;                      /*      +88       */

  u32_t    wnd_shape_scale;                 /*      +132      */

  u32_t    reserved1;                       /*      +136      */

  size_t   mem_size;                        /*      +140      */

}appdata_t;

#pragma pack(pop)

              char *cmdline, u32_t flags) asm ("mnt_exec");

{

    char *p;

    unsigned char c;

    while( (c = *p) )

    {

        if( c >= 'a' && c <= 'z' )

            *p = c - 'a' + 'A';

        ++p;

    }

}

{

int d0, d1, d2;

 __asm__ __volatile__(

	"rep ; movsl\n\t"

	"testb $2,%b4\n\t"

	"je 1f\n\t"

	"movsw\n"

	"1:\ttestb $1,%b4\n\t"

	"je 2f\n\t"

	"movsb\n"

	"2:"

	: "=&c" (d0), "=&D" (d1), "=&S" (d2)

	:"0" (_n/4), "q" (_n),"1" ((long)_dest),"2" ((long)_src)

	: "memory");

 return (_dest);

}

{

int d0;

register int __res;

__asm__ __volatile__(

	"repne\n\t"

	"scasb\n\t"

	"notl %0\n\t"

	"decl %0"

	:"=c" (__res), "=&D" (d0) :"1" (str),"a" (0), "0" (0xffffffff));

return __res;

}

{

    PIMAGE_DOS_HEADER        dos;

    PIMAGE_NT_HEADERS32      nt;

    PIMAGE_EXPORT_DIRECTORY  exp;

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

    exp =  MakePtr(PIMAGE_EXPORT_DIRECTORY,LOAD_BASE,

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

    core_dll.img_size = nt->OptionalHeader.SizeOfImage;

    core_dll.img_md   = NULL;

    core_dll.img_sec  = MakePtr(PIMAGE_SECTION_HEADER,nt, sizeof(IMAGE_NT_HEADERS32));

    core_dll.img_exp  = MakePtr(PIMAGE_EXPORT_DIRECTORY,LOAD_BASE,

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

    core_dll.img_name = strupr(MakePtr(char*, LOAD_BASE, exp->Name));

        core_dll.img_name, core_dll.img_base,

        core_dll.img_size, nt->FileHeader.NumberOfSections,

        core_dll.img_exp );

};

{

    dll_t* dll = (dll_t*)list;

    {

        if( !strncmp(name,dll->img_name,16))

            return dll;

};

{

  char         srv_name[16];  //        ASCIIZ string

  u32_t        magic;         // +0x10  'SRV '

  size_t       size;          // +0x14  size of structure SRV

  void        *fd;            // +0x18  next SRV descriptor

  void        *bk;            // +0x1C  prev SRV descriptor

  addr_t       base;          // +0x20  service base address

  addr_t       entry;         // +0x24  service START function

  void        *srv_proc;      // +0x28  main service handler

}srv_t;

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    md_t          *md;

    srv_t         *srv;

        return 0;

    {

        dos = (PIMAGE_DOS_HEADER)md->base;

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

                            nt->OptionalHeader.AddressOfEntryPoint);

            srv->entry = nt->OptionalHeader.AddressOfEntryPoint + md->base;

    }

    else

    {

        md_free( md );

        return NULL;

    }

}

{

    int a_type;

    union

    {

        long  a_val;

        void *a_ptr;

        void  (*a_fcn)( ) ;

    }a_un;

}auxv_t;

{

    int     argc;       /*  always 2                                */

    char   *path;       /*  argv[0]   program path                  */

    char   *cmdline;    /*  argv[1]   command  line. May be null    */

    u32_t   sep1;       /*  separator.  must be zero                */

    char   *env;        /*  single environment string               */

    u32_t   sep2;       /*  separator.  must be zero                */

    auxv_t  aux[1];     /*  aux. AT_NULL for now                    */

}exec_stack_t;

                          exec_stack_t *ex_stack) asm ("pe_app_param");

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    count_t  img_pages;

    count_t  img_tabs;

    addr_t        ex_pg_dir;

    addr_t        ex_stack_page;

    addr_t        ex_pl0_stack;

    int           stack_size;

    char         *ex_path;

    char         *ex_cmdline = NULL;

    u32_t        *raw;

    int cmdsize  = 0;

    int envsize  = 0;

    {

        DBG("invalid path\n");

        return;

    };

        return -5;                                      /* FIXME */

        ( ( raw[1] == 0x31305445) ||

          ( raw[1] == 0x30305445) ) )

        DBG("leagacy Kolibri application");

        int tmp =  mnt_exec(raw, raw_size, path, cmdline, flags);

        DBG("  pid %x\n",tmp);

        return tmp;

    }

    {

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

        mem_free(raw);

        return -31;

    }

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

        cmdsize = strlen(cmdline)+1;

                 cmdsize + envsize + AUX_COUNT*sizeof(auxv_t);

    {

        DBG("command line too long\n");

        return -30;

    }

    if( ! ex_stack_page )

    {

        mem_free(raw);

        return -30;                                    /* FIXME          */

    };

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

    {

        core_free(ex_stack_page);

        mem_free(raw);

        return -30;                                    /* FIXME          */

    };

    "xorl %%eax, %%eax      \n\t"

    "rep stosl"

    :"=c"(tmp),"=D"(tmp)

    :"c"(1024),"D"(ex_stack_page + OS_BASE)

    :"eax","cc");

                               + PAGE_SIZE - stack_size);

    ex_stack->argc = 2;

    ex_stack->path = (char*)(((addr_t)ex_path & 0xFFF) + 0x7FFFF000);  /* top of stack */

    {

        ex_cmdline = ex_path + pathsize;

        memcpy(ex_cmdline, cmdline, cmdsize);

        ex_stack->cmdline = ex_stack->path + pathsize;

    };

    ex_stack.env = null

    ex_stack.aux[0] = AT_NULL

 */

         ex_stack, ex_stack->path, ex_stack->cmdline);

};

{

    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_IOPL1   0x1000

#define EFL_IOPL2   0x2000

#define EFL_IOPL3   0x3000

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    count_t  img_pages;

    size_t   stack_size;

    addr_t   img_stack;

    addr_t  *pte;

    u32_t    tmp;

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

    img_pages = img_size >> 12;

    img_stack = 0x7FFFF000 - stack_size;

    stack_size>>= 12;

        *pte++ = 2;

        *pte++ = 0x02;

    {

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

        __asm__ __volatile__ (

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

    };

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

                   nt->OptionalHeader.ImageBase;

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

{

    PIMAGE_DOS_HEADER        dos;

    PIMAGE_NT_HEADERS32      nt;

    PIMAGE_EXPORT_DIRECTORY  exp;

    addr_t   img_base;

    count_t  img_pages;

    void    *raw;

    {

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

        return NULL;

    };

    {

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

        mem_free(raw);

        return NULL;

    }

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

    if( !img_base)

    {

        mem_free(raw);

        return NULL;

    };

    if( !dll)

    {

        mem_free(raw);

        user_free((void*)img_base);

        return NULL;

    };

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

    exp =  MakePtr(PIMAGE_EXPORT_DIRECTORY,img_base,

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

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

    dll->img_md   = NULL;

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

};

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    char path[128];

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

    {

        PIMAGE_IMPORT_DESCRIPTOR imp;

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

        {

            PIMAGE_THUNK_DATA32     thunk;

            PIMAGE_NT_HEADERS32     expnt;

            PIMAGE_EXPORT_DIRECTORY exp;

            char    *libname;

            addr_t  *functions;

            u16_t   *ordinals;

            char   **funcname;

                break;

            if(exp_dll != NULL)

            {

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

            }

            else

            {

                int len = strlen(libname)+1;

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

                if( !exp_dll)

                {

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

                    return false;

                };

            }

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

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

                            imp->Characteristics, img_base);

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

            {

                PIMAGE_IMPORT_BY_NAME ord;

                addr_t addr;

                *iat=0;

                    break;

                {

                   u16_t ordinal;

                   ordinal = thunk->u1.Ordinal & 0xFFFF;

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

                    break;

                }

                else

                {

                    ord = MakePtr(PIMAGE_IMPORT_BY_NAME,

                                  thunk->u1.AddressOfData, img_base);

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

                    {

                        int ind;

                        char **names=funcname;

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

                        {

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

                            {

                                u16_t ordinal;

                                ordinal = ordinals[ind];

                                DBG("ordinal %d\t\tat %x\n", ordinal, 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

                    {

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

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

                    };

                };

                thunk++;            // Advance to next thunk

                iat++;

            }

            imp++;  // advance to next IMAGE_IMPORT_DESCRIPTOR

        };

    };

        return true;

    else

        return false;

}