static int open_and_exec(t_shell *shell, t_tree *tree)
{
t_tree *current;
int idx;
int fd_idx;
current = tree;
fd_idx = 0;
while (current->up != NULL)
{
idx = 0;
while (idx != current->up->token)
idx += 1;
if (shell->tk_parsing[idx].f(shell, current, fd_idx++) == -1)
return (-1);
current = current->up;
}
if (do_execve(shell, current->left) == -1)
return (-1);
waiting_all_children(shell);
if (dup2(shell->base_in_out[0], 0) == -1 ||
dup2(shell->base_in_out[1], 1) == -1)
return (-1);
return (0);
}
static uint32_t
sys_exec(uint32_t arg[]) {
const char *name = (const char *)arg[0];
const char **argv = (const char **)arg[1];//kprintf("sys_exec : name=%s argc=%d\n", name, argc);int d;for (d = 0; d < argc; ++d) kprintf("\t#%d: %s\n", d, argv[d]);
const char **envp = (const char **)arg[2];
return do_execve(name, argv, envp);
}
void fork_handler(t_shell *shell, char **args)
{
pid_t p;
p = fork();
if (p == 0)
{
if (execve(args[0], args, shell->env) == -1)
{
if (shell->env == NULL)
{
my_putstr_err(args[0]);
my_putstr_err(": Command not found.\n");
exit(0);
}
do_execve(shell->env, args);
}
exit(0);
}
else if (p != -1)
{
waitpid(0, &shell->status, 0);
}
else
my_putstr_err("FATAL ERROR : Fork failed\n");
}
static uint32_t
sys_execve(uint32_t arg[]) {
const char *name = (const char *)arg[0];
const char **argv = (const char **)arg[1];
const char **envp = (const char **)arg[2];
return do_execve(name, argv, envp);
}
asmlinkage int real_execve(struct pt_regs *regs)
{
int error;
char * filename;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
lock_kernel();
#endif
filename = getname((char *) regs->ebx);
error = PTR_ERR(filename);
if (IS_ERR(filename))
goto out;
error = do_execve(filename, (char **) regs->ecx, (char **) regs->edx, regs);
if (error == 0) {
#ifdef PT_DTRACE
current->ptrace &= ~PT_DTRACE;
#else
current->flags &= ~PF_DTRACE;
#endif
}
putname(filename);
out:
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
unlock_kernel();
#endif
return error;
}
static uint32_t sys_exec(uint32_t arg[])
{
const char *name = (const char *)arg[0];
int argc = (int)arg[1];
const char **argv = (const char **)arg[2];
return do_execve(name, argc, argv);
}
asmlinkage static int my_sys_execve(struct pt_regs regs)
{
char * filename;
int ret;
MOD_INC_USE_COUNT;
lock_execve();
filename = getname((char *)regs.ebx);
if (IS_ERR(filename)) {
ret = PTR_ERR(filename);
goto out;
}
ret = do_execve(filename, (char **)regs.ecx, (char **)regs.edx, ®s);
if (!ret) {
PTRACE_OFF(current);
oprof_output_maps(current);
}
putname(filename);
out:
unlock_execve();
MOD_DEC_USE_COUNT;
return ret;
}
DEFINE_SYSCALL(execve, const char *, filename, char **, argv, char **, envp)
{
/* TODO: Deal with argv/envp == NULL */
/* TODO: Don't destroy things on failure */
log_info("execve(%s, %p, %p)", filename, argv, envp);
/* Copy argv[] and envp[] to startup data */
char *current_startup_base = flip_startup_base();
/* Save filename in startup data area */
int flen = strlen(filename);
memcpy(current_startup_base, filename, flen + 1);
filename = current_startup_base;
current_startup_base += flen + 1;
char *base = current_startup_base;
int argc, env_size;
for (argc = 0; argv[argc]; argc++)
base += strlen(argv[argc]) + 1;
for (env_size = 0; envp[env_size]; env_size++)
base += strlen(envp[env_size]) + 1;
/* TODO: Test if we have enough size to hold the startup data */
char **new_argv = (char **)((uintptr_t)(base + sizeof(void*) - 1) & -sizeof(void*));
char **new_envp = new_argv + argc + 1;
base = current_startup_base;
for (int i = 0; i < argc; i++)
{
new_argv[i] = base;
int len = strlen(argv[i]);
memcpy(base, argv[i], len + 1);
base += len + 1;
}
new_argv[argc] = NULL;
for (int i = 0; i < env_size; i++)
{
new_envp[i] = base;
int len = strlen(envp[i]);
memcpy(base, envp[i], len + 1);
base += len + 1;
}
new_envp[env_size] = NULL;
for (int i = 0; i < argc; i++)
log_info("argv[%d] = \"%s\"", i, new_argv[i]);
for (int i = 0; i < env_size; i++)
log_info("envp[%d] = \"%s\"", i, new_envp[i]);
base = (char *)(new_envp + env_size + 1);
int r = do_execve(filename, argc, new_argv, env_size, new_envp, base, execve_initialize_routine);
if (r < 0) /* Should always be the case */
{
log_warning("execve() failed.");
flip_startup_base();
}
return r;
}
static int sys_exec(uint32_t arg[])
{
const char *name = (const char *) arg[0];
size_t len = (size_t) arg[1];
unsigned char *binary = (unsigned char *) arg[2];
size_t size = (size_t) arg[3];
return do_execve(name, len, binary, size);
}
asmlinkage int
sys_execve(struct pt_regs* regs)
{
dprintk("sys_execve: %s, %p, %p\n",
regs->gregs[0], regs->gregs[1], regs->gregs[2]);
return do_execve((void*)regs->gregs[0], (void*)regs->gregs[1],
(void*)regs->gregs[2], regs);
}
static uint32_t sys_exec(uint32_t arg[])
{
const char *name = (const char *)arg[0];
int argc = (int)arg[1];
const char **argv = (const char **)arg[2];
current->arch.forking = 1;
int ret = do_execve(name, argc, argv);
current->arch.forking = 0;
return ret;
}
/*
* XXX: kern_execve has the astonishing property of not always returning to
* the caller. If sufficiently bad things happen during the call to
* do_execve(), it can end up calling exit1(); as a result, callers must
* avoid doing anything which they might need to undo (e.g., allocating
* memory).
*/
int
kern_execve(struct thread *td, struct image_args *args, struct mac *mac_p)
{
AUDIT_ARG_ARGV(args->begin_argv, args->argc,
args->begin_envv - args->begin_argv);
AUDIT_ARG_ENVV(args->begin_envv, args->envc,
args->endp - args->begin_envv);
return (do_execve(td, args, mac_p));
}
/**
* Exec a user program called by user_main kernel_thread
* Note: we don't need to emulate an interrupt here.
* @param name the name of the process
* @param argv the arguments
*/
int kernel_execve(const char *name, const char **argv)
{
int argc = 0, ret;
while (argv[argc] != NULL) {
argc++;
}
ret = do_execve(name, argc, argv);
kprintf("error with code: %d\n", ret);
return ret;
}
static int execve1(char *file, char **argv, char **env)
{
int error;
error = do_execve(file, argv, env, ¤t->thread.regs);
if (error == 0){
current->ptrace &= ~PT_DTRACE;
set_cmdline(current_cmd());
}
return(error);
}
/*
* sys_execve() executes a new program.
*/
asmlinkage int sys_execve(struct pt_regs *regs)
{
int error;
char * filename;
error = getname((char *) regs->reg4, &filename);
if (error)
return error;
error = do_execve(filename, (char **) regs->reg5,
(char **) regs->reg6, regs);
putname(filename);
return error;
}
void exec_preemptuser(void) {
long err;
err = task_files_init(curr_task);
if(err) {
kpanic("task_files_init failed: %s\n", strerror(-err));
}
err = do_execve("/bin/preemptuser", NULL, NULL, 0);
if(err) {
kpanic("do_execve failed: %s\n", strerror(-err));
}
kill_curr_task(0);
}
/*
* sys_execve() executes a new program.
*
* This works due to the alpha calling sequence: the first 6 args
* are gotten from registers, while the rest is on the stack, so
* we get a0-a5 for free, and then magically find "struct pt_regs"
* on the stack for us..
*
* Don't do this at home.
*/
asmlinkage int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2,
unsigned long a3, unsigned long a4, unsigned long a5,
struct pt_regs regs)
{
int error;
char * filename;
error = getname((char *) a0, &filename);
if (error)
return error;
error = do_execve(filename, (char **) a1, (char **) a2, ®s);
putname(filename);
return error;
}
asmlinkage int sys_execve(char *name, char **argv, char **envp,int dummy,...)
{
int error;
char * filename;
struct pt_regs *regs = (struct pt_regs *) ((unsigned char *)&dummy-4);
filename = getname(name);
error = PTR_ERR(filename);
if (IS_ERR(filename))
return error;
error = do_execve(filename, argv, envp, regs);
putname(filename);
return error;
}
/*
* sys_execve() executes a new program.
*/
asmlinkage int sys_execve(char *name, char **argv, char **envp,int dummy,...)
{
int error;
char * filename,* sp;
struct pt_regs *regs;
sp = (char *) &dummy;
sp+=8;
regs=(struct pt_regs *)sp;
error = getname(name, &filename);
if (error)
return error;
error = do_execve(filename, argv, envp, regs);
putname(filename);
return error;
}
/* sys_execve() executes a new program.
* This is called indirectly via a small wrapper
*/
asmlinkage int sys_execve(char *filenamei, char **argv, char **envp, struct pt_regs *regs)
{
int error;
char * filename;
lock_kernel();
filename = getname(filenamei);
error = PTR_ERR(filename);
if (IS_ERR(filename))
goto out;
error = do_execve(filename, argv, envp, regs);
putname(filename);
out:
unlock_kernel();
return error;
}
/*
* sys_execve() executes a new program.
*/
asmlinkage int sys_execve(abi64_no_regargs, struct pt_regs regs)
{
int error;
char * filename;
filename = getname((char *) (long)regs.regs[4]);
error = PTR_ERR(filename);
if (IS_ERR(filename))
goto out;
error = do_execve(filename, (char **) (long)regs.regs[5],
(char **) (long)regs.regs[6], ®s);
putname(filename);
out:
return error;
}
/*
* sys_execve() executes a new program.
*/
asmlinkage int sys_execve(const char *fname, char **argv, char **envp,
long r13, long mof, long srp,
struct pt_regs *regs)
{
int error;
char *filename;
filename = getname(fname);
error = PTR_ERR(filename);
if (IS_ERR(filename))
goto out;
error = do_execve(filename, argv, envp, regs);
putname(filename);
out:
return error;
}
asmlinkage int sys_execve(struct pt_regs *regs)
{
int error;
char *filename;
filename = getname((char *) regs->gr[26]);
error = PTR_ERR(filename);
if (IS_ERR(filename))
goto out;
error = do_execve(filename, (char **) regs->gr[25],
(char **) regs->gr[24], regs);
if (error == 0)
current->ptrace &= ~PT_DTRACE;
putname(filename);
out:
return error;
}
/*
* sys_execve() executes a new program.
*/
asmlinkage int sys_execve(struct pt_regs regs)
{
int error;
char * filename;
lock_kernel();
filename = getname((char *) get_gpreg(®s, 4));
error = PTR_ERR(filename);
if (IS_ERR(filename))
goto out;
error = do_execve(filename, (char **) get_gpreg(®s, 5),
(char **) get_gpreg(®s, 6), ®s);
putname(filename);
out:
unlock_kernel();
return error;
}
static int sys_execve(execve_args_t *args, regs_t *regs)
{
execve_args_t kern_args;
char *kern_filename = NULL;
char **kern_argv = NULL;
char **kern_envp = NULL;
int err;
if ((err = copy_from_user(&kern_args, args, sizeof(kern_args))) < 0) {
curthr->kt_errno = -err;
goto cleanup;
}
/* copy the name of the executable */
if ((kern_filename = user_strdup(&kern_args.filename)) == NULL)
goto cleanup;
/* copy the argument list */
if (kern_args.argv.av_vec) {
if ((kern_argv = user_vecdup(&kern_args.argv)) == NULL)
goto cleanup;
}
/* copy the environment list */
if (kern_args.envp.av_vec) {
if ((kern_envp = user_vecdup(&kern_args.envp)) == NULL)
goto cleanup;
}
err = do_execve(kern_filename, kern_argv, kern_envp, regs);
curthr->kt_errno = -err;
cleanup:
if (kern_filename)
kfree(kern_filename);
if (kern_argv)
free_vector(kern_argv);
if (kern_envp)
free_vector(kern_envp);
if (curthr->kt_errno)
return -1;
return 0;
}
asmlinkage int virt_execve(struct pt_regs regs)
{
int ret;
char *newfilename;
char *filename = (char *) regs.ebx;
if(!cwd_virtual()) {
ret = real_execve(®s);
if(ret != -ENOENT)
return ret;
}
else
ret = 0;
newfilename = resolve_name(filename, 1, 1);
if(!newfilename) {
if(ret)
return ret;
else
return real_execve(®s);
}
if(IS_ERR(newfilename))
return PTR_ERR(newfilename);
DEB((KERN_INFO "EXECVE: trying '%s'\n", newfilename));
ret = do_execve(newfilename, (char **) regs.ecx, (char **) regs.edx,
®s);
if (ret == 0) {
#ifdef PT_DTRACE
current->ptrace &= ~PT_DTRACE;
#else
current->flags &= ~PF_DTRACE;
#endif
}
kfree(newfilename);
DEB((KERN_INFO "EXECVE: result %i\n", ret));
return ret;
}
int sys_execve(struct tcb *sender, char *pathname,
char *argv[], char *envp[])
{
int ret;
char *path;
struct args_struct args;
struct args_struct env;
if (!(path = kzalloc(PATH_MAX)))
return -ENOMEM;
memset(&args, 0, sizeof(args));
memset(&env, 0, sizeof(env));
/* Copy the executable path string */
if ((ret = copy_user_string(sender, path,
pathname, PATH_MAX)) < 0)
return ret;
/* Copy the args */
if (argv && ((ret = copy_user_args(sender, &args,
argv, ARGS_MAX)) < 0))
goto out1;
/* Copy the env */
if (envp && ((ret = copy_user_args(sender, &env, envp,
ARGS_MAX - args.size))
< 0))
goto out2;
ret = do_execve(sender, path, &args, &env);
if (env.argv)
kfree(env.argv);
out2:
if (args.argv)
kfree(args.argv);
out1:
kfree(path);
return ret;
}
/* kernel-internal execve() */
asmlinkage int
l4_kernelinternal_execve(const char * file,
const char * const * argv,
const char * const * envp)
{
int ret;
struct thread_struct *t = ¤t->thread;
ASSERT(l4_is_invalid_cap(t->user_thread_id));
/* we are going to become a real user task now, so prepare a real
* pt_regs structure. */
/* Enable Interrupts, Set IOPL (needed for X, hwclock etc.) */
t->regs.flags = 0x3200; /* XXX hardcoded */
/* do_execve() will create the user task for us in start_thread()
and call set_fs(USER_DS) in flush_thread. I know this sounds
strange but there are places in the kernel (kernel/kmod.c) which
call execve with parameters inside the kernel. They set fs to
KERNEL_DS before calling execve so we can't set it back to
USER_DS before execve had a chance to look at the name of the
executable. */
ASSERT(segment_eq(get_fs(), KERNEL_DS));
ret = do_execve(file, argv, envp, &t->regs);
if (ret < 0) {
/* we failed -- become a kernel thread again */
if (!l4_is_invalid_cap(t->user_thread_id))
l4lx_task_number_free(t->user_thread_id);
set_fs(KERNEL_DS);
t->user_thread_id = L4_INVALID_CAP;
return -1;
}
l4x_user_dispatcher();
/* not reached */
return 0;
}
asmlinkage int knark_execve(struct pt_regs regs)
{
int error;
char *filename;
lock_kernel();
filename = getname((char *)regs.ebx);
error = PTR_ERR(filename);
if(IS_ERR(filename))
goto out;
error = do_execve(knark_redirect_path(filename), (char **)regs.ecx,
(char **)regs.edx, ®s);
if(error == 0)
// current->flags &= ~PF_DTRACE;
current->flags &= ~PT_DTRACE;
putname(filename);
out:
unlock_kernel();
return error;
}
/*
* sparc_execve() executes a new program after the asm stub has set
* things up for us. This should basically do what I want it to.
*/
asmlinkage int sparc_execve(struct pt_regs *regs)
{
int error;
char *filename;
char *a,**args=regs->u_regs[UREG_I1];
//flush_user_windows();
error = getname((char *) regs->u_regs[UREG_I0], &filename);
if(error)
return error;
/*printk("sparc_execve %s:\n",filename);
while (a=(*(args++)))
printk ("execve %s\n",a);*/
error = do_execve(filename, (char **) regs->u_regs[UREG_I1],
(char **) regs->u_regs[UREG_I2], regs);
putname(filename);
return error;
}
