Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include 

              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 = &core_dll;

    {

        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;

                          addr_t ex_stack_page) asm ("pe_app_param");

{

    addr_t        ex_pg_dir;

    addr_t        ex_stack_tab;

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

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

        return tmp;

    }

    {

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

        mem_free(raw);

        return -31;

    }

        cmdsize = strlen(cmdline)+1;

                 cmdsize + envsize + AUX_COUNT*sizeof(auxv_t);

    {

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

        return -30;

    }

    {

        mem_free(raw);

        return -30;                                    /* FIXME          */

    };

    ex_pl0_stack   = ex_pg_dir + 4096 * 2;

    {

        core_free(ex_stack_tab);

        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) + 0x7FCFF000);  /* 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);

    return 0;

};

{

    PIMAGE_DOS_HEADER     dos;

    PIMAGE_NT_HEADERS32   nt;

    count_t  img_pages;

    count_t  img_tabs;

    count_t  i;

    u32_t    tmp;

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

    img_tabs  = ((img_size + 0x3FFFFF) & ~0x3FFFFF) >> 22;

    {

        addr_t tab = core_alloc(0);

        ((u32_t*)master_tab)[i] = tab|7;                            /*   FIXME     */

    }

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

    "rep stosl"

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

    :"c"(img_tabs<<10),"D"(page_tabs)

    :"eax","cc");

    {

        addr_t page = core_alloc(0);

        ((u32_t*)page_tabs)[i] = page | 7;                          /*   FIXME     */

    }

    "xchgw %bx, %bx");

                   nt->OptionalHeader.ImageBase;

  //  "call %0":: "r" (entry));

>