static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,

                           struct image_info * info)

{

    struct elfhdr elf_ex;

    struct elfhdr interp_elf_ex;

    struct exec interp_ex;

    int interpreter_fd = -1; /* avoid warning */

    unsigned long load_addr, load_bias;

    int load_addr_set = 0;

    unsigned int interpreter_type = INTERPRETER_NONE;

    unsigned char ibcs2_interpreter;

    int i;

    unsigned long mapped_addr;

    struct elf_phdr * elf_ppnt;

    struct elf_phdr *elf_phdata;

    unsigned long elf_bss, k, elf_brk;

    int retval;

    char * elf_interpreter;

    unsigned long elf_entry, interp_load_addr = 0;

    int status;

    unsigned long start_code, end_code, end_data;

    unsigned long elf_stack;

    char passed_fileno[6];



    ibcs2_interpreter = 0;

    status = 0;

    load_addr = 0;

    load_bias = 0;

    elf_ex = *((struct elfhdr *) bprm->buf);          /* exec-header */

#ifdef BSWAP_NEEDED

    bswap_ehdr(&elf_ex);

#endif



    if (elf_ex.e_ident[0] != 0x7f ||

	strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {

	    return  -ENOEXEC;

    }



    /* First of all, some simple consistency checks */

    if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||

       				(! elf_check_arch(elf_ex.e_machine))) {

	    return -ENOEXEC;

    }



    /* Now read in all of the header information */

    elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);

    if (elf_phdata == NULL) {

	return -ENOMEM;

    }



    retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);

    if(retval > 0) {

	retval = read(bprm->fd, (char *) elf_phdata, 

				elf_ex.e_phentsize * elf_ex.e_phnum);

    }



    if (retval < 0) {

	perror("load_elf_binary");

	exit(-1);

	free (elf_phdata);

	return -errno;

    }



#ifdef BSWAP_NEEDED

    elf_ppnt = elf_phdata;

    for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {

        bswap_phdr(elf_ppnt);

    }

#endif

    elf_ppnt = elf_phdata;



    elf_bss = 0;

    elf_brk = 0;





    elf_stack = ~0UL;

    elf_interpreter = NULL;

    start_code = ~0UL;

    end_code = 0;

    end_data = 0;



    for(i=0;i < elf_ex.e_phnum; i++) {

	if (elf_ppnt->p_type == PT_INTERP) {

	    if ( elf_interpreter != NULL )

	    {

		free (elf_phdata);

		free(elf_interpreter);

		close(bprm->fd);

		return -EINVAL;

	    }



	    /* This is the program interpreter used for

	     * shared libraries - for now assume that this

	     * is an a.out format binary

	     */



	    elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);



	    if (elf_interpreter == NULL) {

		free (elf_phdata);

		close(bprm->fd);

		return -ENOMEM;

	    }



	    retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);

	    if(retval >= 0) {

		retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);

	    }

	    if(retval < 0) {

	 	perror("load_elf_binary2");

		exit(-1);

	    }	



	    /* If the program interpreter is one of these two,

	       then assume an iBCS2 image. Otherwise assume

	       a native linux image. */



	    /* JRP - Need to add X86 lib dir stuff here... */



	    if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||

		strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {

	      ibcs2_interpreter = 1;

	    }



#if 0

	    printf("Using ELF interpreter %s\n", elf_interpreter);

#endif

	    if (retval >= 0) {

		retval = open(path(elf_interpreter), O_RDONLY);

		if(retval >= 0) {

		    interpreter_fd = retval;

		}

		else {

		    perror(elf_interpreter);

		    exit(-1);

		    /* retval = -errno; */

		}

	    }



	    if (retval >= 0) {

		retval = lseek(interpreter_fd, 0, SEEK_SET);

		if(retval >= 0) {

		    retval = read(interpreter_fd,bprm->buf,128);

		}

	    }

	    if (retval >= 0) {

		interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */

		interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */

	    }

	    if (retval < 0) {

		perror("load_elf_binary3");

		exit(-1);

		free (elf_phdata);

		free(elf_interpreter);

		close(bprm->fd);

		return retval;

	    }

	}

	elf_ppnt++;

    }



    /* Some simple consistency checks for the interpreter */

    if (elf_interpreter){

	interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;



	/* Now figure out which format our binary is */

	if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&

	    	(N_MAGIC(interp_ex) != QMAGIC)) {

	  interpreter_type = INTERPRETER_ELF;

	}



	if (interp_elf_ex.e_ident[0] != 0x7f ||

	    	strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {

	    interpreter_type &= ~INTERPRETER_ELF;

	}



	if (!interpreter_type) {

	    free(elf_interpreter);

	    free(elf_phdata);

	    close(bprm->fd);

	    return -ELIBBAD;

	}

    }



    /* OK, we are done with that, now set up the arg stuff,

       and then start this sucker up */



    if (!bprm->sh_bang) {

	char * passed_p;



	if (interpreter_type == INTERPRETER_AOUT) {

	    sprintf(passed_fileno, "%d", bprm->fd);

	    passed_p = passed_fileno;



	    if (elf_interpreter) {

		bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);

		bprm->argc++;

	    }

	}

	if (!bprm->p) {

	    if (elf_interpreter) {

	        free(elf_interpreter);

	    }

	    free (elf_phdata);

	    close(bprm->fd);

	    return -E2BIG;

	}

    }



    /* OK, This is the point of no return */

    info->end_data = 0;

    info->end_code = 0;

    info->start_mmap = (unsigned long)ELF_START_MMAP;

    info->mmap = 0;

    elf_entry = (unsigned long) elf_ex.e_entry;



    /* Do this so that we can load the interpreter, if need be.  We will

       change some of these later */

    info->rss = 0;

    bprm->p = setup_arg_pages(bprm->p, bprm, info);

    info->start_stack = bprm->p;



    /* Now we do a little grungy work by mmaping the ELF image into

     * the correct location in memory.  At this point, we assume that

     * the image should be loaded at fixed address, not at a variable

     * address.

     */



    for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {

        int elf_prot = 0;

        int elf_flags = 0;

        unsigned long error;

        

	if (elf_ppnt->p_type != PT_LOAD)

            continue;

        

        if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;

        if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;

        if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

        elf_flags = MAP_PRIVATE | MAP_DENYWRITE;

        if (elf_ex.e_type == ET_EXEC || load_addr_set) {

            elf_flags |= MAP_FIXED;

        } else if (elf_ex.e_type == ET_DYN) {

            /* Try and get dynamic programs out of the way of the default mmap

               base, as well as whatever program they might try to exec.  This

               is because the brk will follow the loader, and is not movable.  */

            /* NOTE: for qemu, we do a big mmap to get enough space

               without harcoding any address */

            error = target_mmap(0, ET_DYN_MAP_SIZE,

                                PROT_NONE, MAP_PRIVATE | MAP_ANON, 

                                -1, 0);

            if (error == -1) {

                perror("mmap");

                exit(-1);

            }

            load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);

        }

        

        error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),

                            (elf_ppnt->p_filesz +

                             TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),

                            elf_prot,

                            (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),

                            bprm->fd,

                            (elf_ppnt->p_offset - 

                             TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));

        if (error == -1) {

            perror("mmap");

            exit(-1);

        }



#ifdef LOW_ELF_STACK

        if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)

            elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);

#endif

        

        if (!load_addr_set) {

            load_addr_set = 1;

            load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;

            if (elf_ex.e_type == ET_DYN) {

                load_bias += error -

                    TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);

                load_addr += load_bias;

            }

        }

        k = elf_ppnt->p_vaddr;

        if (k < start_code) 

            start_code = k;

        k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;

        if (k > elf_bss) 

            elf_bss = k;

        if ((elf_ppnt->p_flags & PF_X) && end_code <  k)

            end_code = k;

        if (end_data < k) 

            end_data = k;

        k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;

        if (k > elf_brk) elf_brk = k;

    }



    elf_entry += load_bias;

    elf_bss += load_bias;

    elf_brk += load_bias;

    start_code += load_bias;

    end_code += load_bias;

    //    start_data += load_bias;

    end_data += load_bias;



    if (elf_interpreter) {

	if (interpreter_type & 1) {

	    elf_entry = load_aout_interp(&interp_ex, interpreter_fd);

	}

	else if (interpreter_type & 2) {

	    elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,

					    &interp_load_addr);

	}



	close(interpreter_fd);

	free(elf_interpreter);



	if (elf_entry == ~0UL) {

	    printf("Unable to load interpreter\n");

	    free(elf_phdata);

	    exit(-1);

	    return 0;

	}

    }



    free(elf_phdata);



    if (loglevel)

	load_symbols(&elf_ex, bprm->fd);



    if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);

    info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);



#ifdef LOW_ELF_STACK

    info->start_stack = bprm->p = elf_stack - 4;

#endif

    bprm->p = (unsigned long)

      create_elf_tables((char *)bprm->p,

		    bprm->argc,

		    bprm->envc,

                    &elf_ex,

                    load_addr, load_bias,

		    interp_load_addr,

		    (interpreter_type == INTERPRETER_AOUT ? 0 : 1),

		    info);

    if (interpreter_type == INTERPRETER_AOUT)

      info->arg_start += strlen(passed_fileno) + 1;

    info->start_brk = info->brk = elf_brk;

    info->end_code = end_code;

    info->start_code = start_code;

    info->end_data = end_data;

    info->start_stack = bprm->p;



    /* Calling set_brk effectively mmaps the pages that we need for the bss and break

       sections */

    set_brk(elf_bss, elf_brk);



    padzero(elf_bss);



#if 0

    printf("(start_brk) %x\n" , info->start_brk);

    printf("(end_code) %x\n" , info->end_code);

    printf("(start_code) %x\n" , info->start_code);

    printf("(end_data) %x\n" , info->end_data);

    printf("(start_stack) %x\n" , info->start_stack);

    printf("(brk) %x\n" , info->brk);

#endif



    if ( info->personality == PER_SVR4 )

    {

	    /* Why this, you ask???  Well SVr4 maps page 0 as read-only,

	       and some applications "depend" upon this behavior.

	       Since we do not have the power to recompile these, we

	       emulate the SVr4 behavior.  Sigh.  */

	    mapped_addr = target_mmap(0, host_page_size, PROT_READ | PROT_EXEC,

                                      MAP_FIXED | MAP_PRIVATE, -1, 0);

    }



#ifdef ELF_PLAT_INIT

    /*

     * The ABI may specify that certain registers be set up in special

     * ways (on i386 %edx is the address of a DT_FINI function, for

     * example.  This macro performs whatever initialization to

     * the regs structure is required.

     */

    ELF_PLAT_INIT(regs);

#endif





    info->entry = elf_entry;



    return 0;

}

static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,

                           struct image_info * info)

{

    struct elfhdr elf_ex;

    struct elfhdr interp_elf_ex;

    struct exec interp_ex;

    int interpreter_fd = -1; 

    unsigned long load_addr, load_bias;

    int load_addr_set = 0;

    unsigned int interpreter_type = INTERPRETER_NONE;

    unsigned char ibcs2_interpreter;

    int i;

    unsigned long mapped_addr;

    struct elf_phdr * elf_ppnt;

    struct elf_phdr *elf_phdata;

    unsigned long elf_bss, k, elf_brk;

    int retval;

    char * elf_interpreter;

    unsigned long elf_entry, interp_load_addr = 0;

    int status;

    unsigned long start_code, end_code, end_data;

    unsigned long elf_stack;

    char passed_fileno[6];



    ibcs2_interpreter = 0;

    status = 0;

    load_addr = 0;

    load_bias = 0;

    elf_ex = *((struct elfhdr *) bprm->buf);          

#ifdef BSWAP_NEEDED

    bswap_ehdr(&elf_ex);

#endif



    if (elf_ex.e_ident[0] != 0x7f ||

	strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {

	    return  -ENOEXEC;

    }



    

    if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||

       				(! elf_check_arch(elf_ex.e_machine))) {

	    return -ENOEXEC;

    }



    

    elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);

    if (elf_phdata == NULL) {

	return -ENOMEM;

    }



    retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);

    if(retval > 0) {

	retval = read(bprm->fd, (char *) elf_phdata, 

				elf_ex.e_phentsize * elf_ex.e_phnum);

    }



    if (retval < 0) {

	perror("load_elf_binary");

	exit(-1);

	free (elf_phdata);

	return -errno;

    }



#ifdef BSWAP_NEEDED

    elf_ppnt = elf_phdata;

    for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {

        bswap_phdr(elf_ppnt);

    }

#endif

    elf_ppnt = elf_phdata;



    elf_bss = 0;

    elf_brk = 0;





    elf_stack = ~0UL;

    elf_interpreter = NULL;

    start_code = ~0UL;

    end_code = 0;

    end_data = 0;



    for(i=0;i < elf_ex.e_phnum; i++) {

	if (elf_ppnt->p_type == PT_INTERP) {

	    if ( elf_interpreter != NULL )

	    {

		free (elf_phdata);

		free(elf_interpreter);

		close(bprm->fd);

		return -EINVAL;

	    }



	    









	    elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);



	    if (elf_interpreter == NULL) {

		free (elf_phdata);

		close(bprm->fd);

		return -ENOMEM;

	    }



	    retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);

	    if(retval >= 0) {

		retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);

	    }

	    if(retval < 0) {

	 	perror("load_elf_binary2");

		exit(-1);

	    }	



	    







	    



	    if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||

		strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {

	      ibcs2_interpreter = 1;

	    }



#if 0

	    printf("Using ELF interpreter %s\n", elf_interpreter);

#endif

	    if (retval >= 0) {

		retval = open(path(elf_interpreter), O_RDONLY);

		if(retval >= 0) {

		    interpreter_fd = retval;

		}

		else {

		    perror(elf_interpreter);

		    exit(-1);

		    

		}

	    }



	    if (retval >= 0) {

		retval = lseek(interpreter_fd, 0, SEEK_SET);

		if(retval >= 0) {

		    retval = read(interpreter_fd,bprm->buf,128);

		}

	    }

	    if (retval >= 0) {

		interp_ex = *((struct exec *) bprm->buf); 

		interp_elf_ex=*((struct elfhdr *) bprm->buf); 

	    }

	    if (retval < 0) {

		perror("load_elf_binary3");

		exit(-1);

		free (elf_phdata);

		free(elf_interpreter);

		close(bprm->fd);

		return retval;

	    }

	}

	elf_ppnt++;

    }



    

    if (elf_interpreter){

	interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;



	

	if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&

	    	(N_MAGIC(interp_ex) != QMAGIC)) {

	  interpreter_type = INTERPRETER_ELF;

	}



	if (interp_elf_ex.e_ident[0] != 0x7f ||

	    	strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {

	    interpreter_type &= ~INTERPRETER_ELF;

	}



	if (!interpreter_type) {

	    free(elf_interpreter);

	    free(elf_phdata);

	    close(bprm->fd);

	    return -ELIBBAD;

	}

    }



    





    if (!bprm->sh_bang) {

	char * passed_p;



	if (interpreter_type == INTERPRETER_AOUT) {

	    sprintf(passed_fileno, "%d", bprm->fd);

	    passed_p = passed_fileno;



	    if (elf_interpreter) {

		bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);

		bprm->argc++;

	    }

	}

	if (!bprm->p) {

	    if (elf_interpreter) {

	        free(elf_interpreter);

	    }

	    free (elf_phdata);

	    close(bprm->fd);

	    return -E2BIG;

	}

    }



    

    info->end_data = 0;

    info->end_code = 0;

    info->start_mmap = (unsigned long)ELF_START_MMAP;

    info->mmap = 0;

    elf_entry = (unsigned long) elf_ex.e_entry;



    



    info->rss = 0;

    bprm->p = setup_arg_pages(bprm->p, bprm, info);

    info->start_stack = bprm->p;



    











    for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {

        int elf_prot = 0;

        int elf_flags = 0;

        unsigned long error;

        

	if (elf_ppnt->p_type != PT_LOAD)

            continue;

        

        if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;

        if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;

        if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

        elf_flags = MAP_PRIVATE | MAP_DENYWRITE;

        if (elf_ex.e_type == ET_EXEC || load_addr_set) {

            elf_flags |= MAP_FIXED;

        } else if (elf_ex.e_type == ET_DYN) {

            





            



            error = target_mmap(0, ET_DYN_MAP_SIZE,

                                PROT_NONE, MAP_PRIVATE | MAP_ANON, 

                                -1, 0);

            if (error == -1) {

                perror("mmap");

                exit(-1);

            }

            load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);

        }

        

        error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),

                            (elf_ppnt->p_filesz +

                             TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),

                            elf_prot,

                            (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),

                            bprm->fd,

                            (elf_ppnt->p_offset - 

                             TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));

        if (error == -1) {

            perror("mmap");

            exit(-1);

        }



#ifdef LOW_ELF_STACK

        if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)

            elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);

#endif

        

        if (!load_addr_set) {

            load_addr_set = 1;

            load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;

            if (elf_ex.e_type == ET_DYN) {

                load_bias += error -

                    TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);

                load_addr += load_bias;

            }

        }

        k = elf_ppnt->p_vaddr;

        if (k < start_code) 

            start_code = k;

        k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;

        if (k > elf_bss) 

            elf_bss = k;

        if ((elf_ppnt->p_flags & PF_X) && end_code <  k)

            end_code = k;

        if (end_data < k) 

            end_data = k;

        k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;

        if (k > elf_brk) elf_brk = k;

    }



    elf_entry += load_bias;

    elf_bss += load_bias;

    elf_brk += load_bias;

    start_code += load_bias;

    end_code += load_bias;

    

    end_data += load_bias;



    if (elf_interpreter) {

	if (interpreter_type & 1) {

	    elf_entry = load_aout_interp(&interp_ex, interpreter_fd);

	}

	else if (interpreter_type & 2) {

	    elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,

					    &interp_load_addr);

	}



	close(interpreter_fd);

	free(elf_interpreter);



	if (elf_entry == ~0UL) {

	    printf("Unable to load interpreter\n");

	    free(elf_phdata);

	    exit(-1);

	    return 0;

	}

    }



    free(elf_phdata);



    if (loglevel)

	load_symbols(&elf_ex, bprm->fd);



    if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);

    info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);



#ifdef LOW_ELF_STACK

    info->start_stack = bprm->p = elf_stack - 4;

#endif

    bprm->p = (unsigned long)

      create_elf_tables((char *)bprm->p,

		    bprm->argc,

		    bprm->envc,

                    &elf_ex,

                    load_addr, load_bias,

		    interp_load_addr,

		    (interpreter_type == INTERPRETER_AOUT ? 0 : 1),

		    info);

    if (interpreter_type == INTERPRETER_AOUT)

      info->arg_start += strlen(passed_fileno) + 1;

    info->start_brk = info->brk = elf_brk;

    info->end_code = end_code;

    info->start_code = start_code;

    info->end_data = end_data;

    info->start_stack = bprm->p;



    



    set_brk(elf_bss, elf_brk);



    padzero(elf_bss);



#if 0

    printf("(start_brk) %x\n" , info->start_brk);

    printf("(end_code) %x\n" , info->end_code);

    printf("(start_code) %x\n" , info->start_code);

    printf("(end_data) %x\n" , info->end_data);

    printf("(start_stack) %x\n" , info->start_stack);

    printf("(brk) %x\n" , info->brk);

#endif



    if ( info->personality == PER_SVR4 )

    {

	    







	    mapped_addr = target_mmap(0, host_page_size, PROT_READ | PROT_EXEC,

                                      MAP_FIXED | MAP_PRIVATE, -1, 0);

    }



#ifdef ELF_PLAT_INIT

    











    ELF_PLAT_INIT(regs);

#endif





    info->entry = elf_entry;



    return 0;

}

	    sprintf(passed_fileno, "%d", bprm->fd);
static int FUNC_0(struct linux_binprm * VAR_0, struct target_pt_regs * VAR_1,

                           struct image_info * VAR_2)

{

    struct elfhdr VAR_3;

    struct elfhdr VAR_4;

    struct exec VAR_5;

    int VAR_6 = -1; 

    unsigned long VAR_7, VAR_8;

    int VAR_9 = 0;

    unsigned int VAR_10 = INTERPRETER_NONE;

    unsigned char VAR_11;

    int VAR_12;

    unsigned long VAR_13;

    struct elf_phdr * VAR_14;

    struct elf_phdr *VAR_15;

    unsigned long VAR_16, VAR_17, VAR_18;

    int VAR_19;

    char * VAR_20;

    unsigned long VAR_21, VAR_22 = 0;

    int VAR_23;

    unsigned long VAR_24, VAR_25, VAR_26;

    unsigned long VAR_27;

    char VAR_28[6];



    VAR_11 = 0;

    VAR_23 = 0;

    VAR_7 = 0;

    VAR_8 = 0;

    VAR_3 = *((struct elfhdr *) VAR_0->buf);          

#ifdef BSWAP_NEEDED

    bswap_ehdr(&VAR_3);

#endif



    if (VAR_3.e_ident[0] != 0x7f ||

	strncmp(&VAR_3.e_ident[1], "ELF",3) != 0) {

	    return  -ENOEXEC;

    }



    

    if ((VAR_3.e_type != ET_EXEC && VAR_3.e_type != ET_DYN) ||

       				(! elf_check_arch(VAR_3.e_machine))) {

	    return -ENOEXEC;

    }



    

    VAR_15 = (struct elf_phdr *)malloc(VAR_3.e_phentsize*VAR_3.e_phnum);

    if (VAR_15 == NULL) {

	return -ENOMEM;

    }



    VAR_19 = lseek(VAR_0->fd, VAR_3.e_phoff, SEEK_SET);

    if(VAR_19 > 0) {

	VAR_19 = read(VAR_0->fd, (char *) VAR_15, 

				VAR_3.e_phentsize * VAR_3.e_phnum);

    }



    if (VAR_19 < 0) {

	perror("FUNC_0");

	exit(-1);

	free (VAR_15);

	return -errno;

    }



#ifdef BSWAP_NEEDED

    VAR_14 = VAR_15;

    for (VAR_12=0; VAR_12<VAR_3.e_phnum; VAR_12++, VAR_14++) {

        bswap_phdr(VAR_14);

    }

#endif

    VAR_14 = VAR_15;



    VAR_16 = 0;

    VAR_18 = 0;





    VAR_27 = ~0UL;

    VAR_20 = NULL;

    VAR_24 = ~0UL;

    VAR_25 = 0;

    VAR_26 = 0;



    for(VAR_12=0;VAR_12 < VAR_3.e_phnum; VAR_12++) {

	if (VAR_14->p_type == PT_INTERP) {

	    if ( VAR_20 != NULL )

	    {

		free (VAR_15);

		free(VAR_20);

		close(VAR_0->fd);

		return -EINVAL;

	    }



	    









	    VAR_20 = (char *)malloc(VAR_14->p_filesz);



	    if (VAR_20 == NULL) {

		free (VAR_15);

		close(VAR_0->fd);

		return -ENOMEM;

	    }



	    VAR_19 = lseek(VAR_0->fd, VAR_14->p_offset, SEEK_SET);

	    if(VAR_19 >= 0) {

		VAR_19 = read(VAR_0->fd, VAR_20, VAR_14->p_filesz);

	    }

	    if(VAR_19 < 0) {

	 	perror("load_elf_binary2");

		exit(-1);

	    }	



	    







	    



	    if (strcmp(VAR_20,"/usr/lib/libc.so.1") == 0 ||

		strcmp(VAR_20,"/usr/lib/ld.so.1") == 0) {

	      VAR_11 = 1;

	    }



#if 0

	    printf("Using ELF interpreter %s\n", VAR_20);

#endif

	    if (VAR_19 >= 0) {

		VAR_19 = open(path(VAR_20), O_RDONLY);

		if(VAR_19 >= 0) {

		    VAR_6 = VAR_19;

		}

		else {

		    perror(VAR_20);

		    exit(-1);

		    

		}

	    }



	    if (VAR_19 >= 0) {

		VAR_19 = lseek(VAR_6, 0, SEEK_SET);

		if(VAR_19 >= 0) {

		    VAR_19 = read(VAR_6,VAR_0->buf,128);

		}

	    }

	    if (VAR_19 >= 0) {

		VAR_5 = *((struct exec *) VAR_0->buf); 

		VAR_4=*((struct elfhdr *) VAR_0->buf); 

	    }

	    if (VAR_19 < 0) {

		perror("load_elf_binary3");

		exit(-1);

		free (VAR_15);

		free(VAR_20);

		close(VAR_0->fd);

		return VAR_19;

	    }

	}

	VAR_14++;

    }



    

    if (VAR_20){

	VAR_10 = INTERPRETER_ELF | INTERPRETER_AOUT;



	

	if ((N_MAGIC(VAR_5) != OMAGIC) && (N_MAGIC(VAR_5) != ZMAGIC) &&

	    	(N_MAGIC(VAR_5) != QMAGIC)) {

	  VAR_10 = INTERPRETER_ELF;

	}



	if (VAR_4.e_ident[0] != 0x7f ||

	    	strncmp(&VAR_4.e_ident[1], "ELF",3) != 0) {

	    VAR_10 &= ~INTERPRETER_ELF;

	}



	if (!VAR_10) {

	    free(VAR_20);

	    free(VAR_15);

	    close(VAR_0->fd);

	    return -ELIBBAD;

	}

    }



    





    if (!VAR_0->sh_bang) {

	char * VAR_29;



	if (VAR_10 == INTERPRETER_AOUT) {

	    sprintf(VAR_28, "%d", VAR_0->fd);

	    VAR_29 = VAR_28;



	    if (VAR_20) {

		VAR_0->p = copy_strings(1,&VAR_29,VAR_0->page,VAR_0->p);

		VAR_0->argc++;

	    }

	}

	if (!VAR_0->p) {

	    if (VAR_20) {

	        free(VAR_20);

	    }

	    free (VAR_15);

	    close(VAR_0->fd);

	    return -E2BIG;

	}

    }



    

    VAR_2->VAR_26 = 0;

    VAR_2->VAR_25 = 0;

    VAR_2->start_mmap = (unsigned long)ELF_START_MMAP;

    VAR_2->mmap = 0;

    VAR_21 = (unsigned long) VAR_3.e_entry;



    



    VAR_2->rss = 0;

    VAR_0->p = setup_arg_pages(VAR_0->p, VAR_0, VAR_2);

    VAR_2->start_stack = VAR_0->p;



    











    for(VAR_12 = 0, VAR_14 = VAR_15; VAR_12 < VAR_3.e_phnum; VAR_12++, VAR_14++) {

        int elf_prot = 0;

        int elf_flags = 0;

        unsigned long error;

        

	if (VAR_14->p_type != PT_LOAD)

            continue;

        

        if (VAR_14->p_flags & PF_R) elf_prot |= PROT_READ;

        if (VAR_14->p_flags & PF_W) elf_prot |= PROT_WRITE;

        if (VAR_14->p_flags & PF_X) elf_prot |= PROT_EXEC;

        elf_flags = MAP_PRIVATE | MAP_DENYWRITE;

        if (VAR_3.e_type == ET_EXEC || VAR_9) {

            elf_flags |= MAP_FIXED;

        } else if (VAR_3.e_type == ET_DYN) {

            





            



            error = target_mmap(0, ET_DYN_MAP_SIZE,

                                PROT_NONE, MAP_PRIVATE | MAP_ANON, 

                                -1, 0);

            if (error == -1) {

                perror("mmap");

                exit(-1);

            }

            VAR_8 = TARGET_ELF_PAGESTART(error - VAR_14->p_vaddr);

        }

        

        error = target_mmap(TARGET_ELF_PAGESTART(VAR_8 + VAR_14->p_vaddr),

                            (VAR_14->p_filesz +

                             TARGET_ELF_PAGEOFFSET(VAR_14->p_vaddr)),

                            elf_prot,

                            (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),

                            VAR_0->fd,

                            (VAR_14->p_offset - 

                             TARGET_ELF_PAGEOFFSET(VAR_14->p_vaddr)));

        if (error == -1) {

            perror("mmap");

            exit(-1);

        }



#ifdef LOW_ELF_STACK

        if (TARGET_ELF_PAGESTART(VAR_14->p_vaddr) < VAR_27)

            VAR_27 = TARGET_ELF_PAGESTART(VAR_14->p_vaddr);

#endif

        

        if (!VAR_9) {

            VAR_9 = 1;

            VAR_7 = VAR_14->p_vaddr - VAR_14->p_offset;

            if (VAR_3.e_type == ET_DYN) {

                VAR_8 += error -

                    TARGET_ELF_PAGESTART(VAR_8 + VAR_14->p_vaddr);

                VAR_7 += VAR_8;

            }

        }

        VAR_17 = VAR_14->p_vaddr;

        if (VAR_17 < VAR_24) 

            VAR_24 = VAR_17;

        VAR_17 = VAR_14->p_vaddr + VAR_14->p_filesz;

        if (VAR_17 > VAR_16) 

            VAR_16 = VAR_17;

        if ((VAR_14->p_flags & PF_X) && VAR_25 <  VAR_17)

            VAR_25 = VAR_17;

        if (VAR_26 < VAR_17) 

            VAR_26 = VAR_17;

        VAR_17 = VAR_14->p_vaddr + VAR_14->p_memsz;

        if (VAR_17 > VAR_18) VAR_18 = VAR_17;

    }



    VAR_21 += VAR_8;

    VAR_16 += VAR_8;

    VAR_18 += VAR_8;

    VAR_24 += VAR_8;

    VAR_25 += VAR_8;

    

    VAR_26 += VAR_8;



    if (VAR_20) {

	if (VAR_10 & 1) {

	    VAR_21 = load_aout_interp(&VAR_5, VAR_6);

	}

	else if (VAR_10 & 2) {

	    VAR_21 = load_elf_interp(&VAR_4, VAR_6,

					    &VAR_22);

	}



	close(VAR_6);

	free(VAR_20);



	if (VAR_21 == ~0UL) {

	    printf("Unable to load interpreter\n");

	    free(VAR_15);

	    exit(-1);

	    return 0;

	}

    }



    free(VAR_15);



    if (loglevel)

	load_symbols(&VAR_3, VAR_0->fd);



    if (VAR_10 != INTERPRETER_AOUT) close(VAR_0->fd);

    VAR_2->personality = (VAR_11 ? PER_SVR4 : PER_LINUX);



#ifdef LOW_ELF_STACK

    VAR_2->start_stack = VAR_0->p = VAR_27 - 4;

#endif

    VAR_0->p = (unsigned long)

      create_elf_tables((char *)VAR_0->p,

		    VAR_0->argc,

		    VAR_0->envc,

                    &VAR_3,

                    VAR_7, VAR_8,

		    VAR_22,

		    (VAR_10 == INTERPRETER_AOUT ? 0 : 1),

		    VAR_2);

    if (VAR_10 == INTERPRETER_AOUT)

      VAR_2->arg_start += strlen(VAR_28) + 1;

    VAR_2->start_brk = VAR_2->brk = VAR_18;

    VAR_2->VAR_25 = VAR_25;

    VAR_2->VAR_24 = VAR_24;

    VAR_2->VAR_26 = VAR_26;

    VAR_2->start_stack = VAR_0->p;



    



    set_brk(VAR_16, VAR_18);



    padzero(VAR_16);



#if 0

    printf("(start_brk) %x\n" , VAR_2->start_brk);

    printf("(VAR_25) %x\n" , VAR_2->VAR_25);

    printf("(VAR_24) %x\n" , VAR_2->VAR_24);

    printf("(VAR_26) %x\n" , VAR_2->VAR_26);

    printf("(start_stack) %x\n" , VAR_2->start_stack);

    printf("(brk) %x\n" , VAR_2->brk);

#endif



    if ( VAR_2->personality == PER_SVR4 )

    {

	    







	    VAR_13 = target_mmap(0, host_page_size, PROT_READ | PROT_EXEC,

                                      MAP_FIXED | MAP_PRIVATE, -1, 0);

    }



#ifdef ELF_PLAT_INIT

    











    ELF_PLAT_INIT(VAR_1);

#endif





    VAR_2->entry = VAR_21;



    return 0;

}

static int FUNC_0(struct linux_binprm * VAR_0, struct target_pt_regs * VAR_1,
struct image_info * VAR_2)
{ struct elfhdr VAR_3; struct elfhdr VAR_4; struct exec VAR_5; int VAR_6 = -1; unsigned long VAR_7, VAR_8; int VAR_9 = 0; unsigned int VAR_10 = INTERPRETER_NONE; unsigned char VAR_11; int VAR_12; unsigned long VAR_13; struct elf_phdr * VAR_14; struct elf_phdr *VAR_15; unsigned long VAR_16, VAR_17, VAR_18; int VAR_19; char * VAR_20; unsigned long VAR_21, VAR_22 = 0; int VAR_23; unsigned long VAR_24, VAR_25, VAR_26; unsigned long VAR_27; char VAR_28[6]; VAR_11 = 0; VAR_23 = 0; VAR_7 = 0; VAR_8 = 0; VAR_3 = *((struct elfhdr *) VAR_0->buf); #ifdef BSWAP_NEEDED
bswap_ehdr(&VAR_3); #endif
if (VAR_3.e_ident[0] != 0x7f ||
strncmp(&VAR_3.e_ident[1], "ELF",3) != 0) { return  -ENOEXEC; } if ((VAR_3.e_type != ET_EXEC && VAR_3.e_type != ET_DYN) ||
(! elf_check_arch(VAR_3.e_machine))) { return -ENOEXEC; } VAR_15 = (struct elf_phdr *)malloc(VAR_3.e_phentsize*VAR_3.e_phnum); if (VAR_15 == NULL) { return -ENOMEM; } VAR_19 = lseek(VAR_0->fd, VAR_3.e_phoff, SEEK_SET); if(VAR_19 > 0) { VAR_19 = read(VAR_0->fd, (char *) VAR_15,
VAR_3.e_phentsize * VAR_3.e_phnum); } if (VAR_19 < 0) { perror("FUNC_0"); exit(-1); free (VAR_15); return -errno; } #ifdef BSWAP_NEEDED
VAR_14 = VAR_15; for (VAR_12=0; VAR_12<VAR_3.e_phnum; VAR_12++, VAR_14++) { bswap_phdr(VAR_14); } #endif
VAR_14 = VAR_15; VAR_16 = 0; VAR_18 = 0; VAR_27 = ~0UL; VAR_20 = NULL; VAR_24 = ~0UL; VAR_25 = 0; VAR_26 = 0; for(VAR_12=0;VAR_12 < VAR_3.e_phnum; VAR_12++) { if (VAR_14->p_type == PT_INTERP) { if ( VAR_20 != NULL )
{ free (VAR_15); free(VAR_20); close(VAR_0->fd); return -EINVAL; } VAR_20 = (char *)malloc(VAR_14->p_filesz); if (VAR_20 == NULL) { free (VAR_15); close(VAR_0->fd); return -ENOMEM; } VAR_19 = lseek(VAR_0->fd, VAR_14->p_offset, SEEK_SET); if(VAR_19 >= 0) { VAR_19 = read(VAR_0->fd, VAR_20, VAR_14->p_filesz); } if(VAR_19 < 0) { perror("load_elf_binary2"); exit(-1); } if (strcmp(VAR_20,"/usr/lib/libc.so.1") == 0 ||
strcmp(VAR_20,"/usr/lib/ld.so.1") == 0) { VAR_11 = 1; } #if 0
printf("Using ELF interpreter %s\n", VAR_20); #endif
if (VAR_19 >= 0) { VAR_19 = open(path(VAR_20), O_RDONLY); if(VAR_19 >= 0) { VAR_6 = VAR_19; } else { perror(VAR_20); exit(-1); } } if (VAR_19 >= 0) { VAR_19 = lseek(VAR_6, 0, SEEK_SET); if(VAR_19 >= 0) { VAR_19 = read(VAR_6,VAR_0->buf,128); } } if (VAR_19 >= 0) { VAR_5 = *((struct exec *) VAR_0->buf); VAR_4=*((struct elfhdr *) VAR_0->buf); } if (VAR_19 < 0) { perror("load_elf_binary3"); exit(-1); free (VAR_15); free(VAR_20); close(VAR_0->fd); return VAR_19; } } VAR_14++; } if (VAR_20){ VAR_10 = INTERPRETER_ELF | INTERPRETER_AOUT; if ((N_MAGIC(VAR_5) != OMAGIC) && (N_MAGIC(VAR_5) != ZMAGIC) &&
(N_MAGIC(VAR_5) != QMAGIC)) { VAR_10 = INTERPRETER_ELF; } if (VAR_4.e_ident[0] != 0x7f ||
strncmp(&VAR_4.e_ident[1], "ELF",3) != 0) { VAR_10 &= ~INTERPRETER_ELF; } if (!VAR_10) { free(VAR_20); free(VAR_15); close(VAR_0->fd); return -ELIBBAD; } } if (!VAR_0->sh_bang) { char * VAR_29; if (VAR_10 == INTERPRETER_AOUT) { sprintf(VAR_28, "%d", VAR_0->fd); VAR_29 = VAR_28; if (VAR_20) { VAR_0->p = copy_strings(1,&VAR_29,VAR_0->page,VAR_0->p); VAR_0->argc++; } } if (!VAR_0->p) { if (VAR_20) { free(VAR_20); } free (VAR_15); close(VAR_0->fd); return -E2BIG; } } VAR_2->VAR_26 = 0; VAR_2->VAR_25 = 0; VAR_2->start_mmap = (unsigned long)ELF_START_MMAP; VAR_2->mmap = 0; VAR_21 = (unsigned long) VAR_3.e_entry; VAR_2->rss = 0; VAR_0->p = setup_arg_pages(VAR_0->p, VAR_0, VAR_2); VAR_2->start_stack = VAR_0->p; for(VAR_12 = 0, VAR_14 = VAR_15; VAR_12 < VAR_3.e_phnum; VAR_12++, VAR_14++) { int elf_prot = 0; int elf_flags = 0; unsigned long error; if (VAR_14->p_type != PT_LOAD)
continue; if (VAR_14->p_flags & PF_R) elf_prot |= PROT_READ; if (VAR_14->p_flags & PF_W) elf_prot |= PROT_WRITE; if (VAR_14->p_flags & PF_X) elf_prot |= PROT_EXEC; elf_flags = MAP_PRIVATE | MAP_DENYWRITE; if (VAR_3.e_type == ET_EXEC || VAR_9) { elf_flags |= MAP_FIXED; } else if (VAR_3.e_type == ET_DYN) { error = target_mmap(0, ET_DYN_MAP_SIZE,
PROT_NONE, MAP_PRIVATE | MAP_ANON,
-1, 0); if (error == -1) { perror("mmap"); exit(-1); } VAR_8 = TARGET_ELF_PAGESTART(error - VAR_14->p_vaddr); } error = target_mmap(TARGET_ELF_PAGESTART(VAR_8 + VAR_14->p_vaddr),
(VAR_14->p_filesz +
TARGET_ELF_PAGEOFFSET(VAR_14->p_vaddr)),
elf_prot,
(MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
VAR_0->fd,
(VAR_14->p_offset -
TARGET_ELF_PAGEOFFSET(VAR_14->p_vaddr))); if (error == -1) { perror("mmap"); exit(-1); } #ifdef LOW_ELF_STACK
if (TARGET_ELF_PAGESTART(VAR_14->p_vaddr) < VAR_27)
VAR_27 = TARGET_ELF_PAGESTART(VAR_14->p_vaddr); #endif
if (!VAR_9) { VAR_9 = 1; VAR_7 = VAR_14->p_vaddr - VAR_14->p_offset; if (VAR_3.e_type == ET_DYN) { VAR_8 += error -
TARGET_ELF_PAGESTART(VAR_8 + VAR_14->p_vaddr); VAR_7 += VAR_8; } } VAR_17 = VAR_14->p_vaddr; if (VAR_17 < VAR_24)
VAR_24 = VAR_17; VAR_17 = VAR_14->p_vaddr + VAR_14->p_filesz; if (VAR_17 > VAR_16)
VAR_16 = VAR_17; if ((VAR_14->p_flags & PF_X) && VAR_25 <  VAR_17)
VAR_25 = VAR_17; if (VAR_26 < VAR_17)
VAR_26 = VAR_17; VAR_17 = VAR_14->p_vaddr + VAR_14->p_memsz; if (VAR_17 > VAR_18) VAR_18 = VAR_17; } VAR_21 += VAR_8; VAR_16 += VAR_8; VAR_18 += VAR_8; VAR_24 += VAR_8; VAR_25 += VAR_8; VAR_26 += VAR_8; if (VAR_20) { if (VAR_10 & 1) { VAR_21 = load_aout_interp(&VAR_5, VAR_6); } else if (VAR_10 & 2) { VAR_21 = load_elf_interp(&VAR_4, VAR_6,
&VAR_22); } close(VAR_6); free(VAR_20); if (VAR_21 == ~0UL) { printf("Unable to load interpreter\n"); free(VAR_15); exit(-1); return 0; } } free(VAR_15); if (loglevel)
load_symbols(&VAR_3, VAR_0->fd); if (VAR_10 != INTERPRETER_AOUT) close(VAR_0->fd); VAR_2->personality = (VAR_11 ? PER_SVR4 : PER_LINUX); #ifdef LOW_ELF_STACK
VAR_2->start_stack = VAR_0->p = VAR_27 - 4; #endif
VAR_0->p = (unsigned long)
create_elf_tables((char *)VAR_0->p,
VAR_0->argc,
VAR_0->envc,
&VAR_3,
VAR_7, VAR_8,
VAR_22,
(VAR_10 == INTERPRETER_AOUT ? 0 : 1),
VAR_2); if (VAR_10 == INTERPRETER_AOUT)
VAR_2->arg_start += strlen(VAR_28) + 1; VAR_2->start_brk = VAR_2->brk = VAR_18; VAR_2->VAR_25 = VAR_25; VAR_2->VAR_24 = VAR_24; VAR_2->VAR_26 = VAR_26; VAR_2->start_stack = VAR_0->p; set_brk(VAR_16, VAR_18); padzero(VAR_16); #if 0
printf("(start_brk) %x\n" , VAR_2->start_brk); printf("(VAR_25) %x\n" , VAR_2->VAR_25); printf("(VAR_24) %x\n" , VAR_2->VAR_24); printf("(VAR_26) %x\n" , VAR_2->VAR_26); printf("(start_stack) %x\n" , VAR_2->start_stack); printf("(brk) %x\n" , VAR_2->brk); #endif
if ( VAR_2->personality == PER_SVR4 )
{ VAR_13 = target_mmap(0, host_page_size, PROT_READ | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE, -1, 0); } #ifdef ELF_PLAT_INIT
ELF_PLAT_INIT(VAR_1); #endif
VAR_2->entry = VAR_21; return 0; }