138 lines
4 KiB
C
138 lines
4 KiB
C
/* ************************************************************************** */
|
|
/* */
|
|
/* ::: :::::::: */
|
|
/* exec_command.c :+: :+: :+: */
|
|
/* +:+ +:+ +:+ */
|
|
/* By: jschaft <cecile.schaft@orange.fr> +#+ +:+ +#+ */
|
|
/* +#+#+#+#+#+ +#+ */
|
|
/* Created: 2024/04/24 13:48:00 by jschaft #+# #+# */
|
|
/* Updated: 2024/06/21 15:57:28 by mcolonna ### ########.fr */
|
|
/* */
|
|
/* ************************************************************************** */
|
|
|
|
#include "include.h"
|
|
|
|
typedef struct s_exec_command_global
|
|
{
|
|
t_memclass mc;
|
|
int nb_calls;
|
|
t_pipes *pipes;
|
|
} t_exec_command_global;
|
|
|
|
static void close_all_pipes(t_exec_command_global *global)
|
|
{
|
|
int i;
|
|
|
|
i = 0;
|
|
if (global->pipes[i].pipe[0] != 0)
|
|
if (close(global->pipes[i].pipe[0]) < 0)
|
|
minishell_error("errno");
|
|
while (++i < global->nb_calls)
|
|
{
|
|
if (close(global->pipes[i].pipe[0]) < 0)
|
|
minishell_error("errno");
|
|
if (close(global->pipes[i].pipe[1]) < 0)
|
|
minishell_error("errno");
|
|
}
|
|
if (global->pipes[i].pipe[1] != 1)
|
|
if (close(global->pipes[i].pipe[1]) < 0)
|
|
minishell_error("errno");
|
|
}
|
|
|
|
// Execute a program with specific stdin and stdout:
|
|
// - inout[0] is stdin
|
|
// - inout[0] is stdout
|
|
// If call.program doesn't start with "./" or "/", find the program in $PATH.
|
|
// (TODO)
|
|
// If the program wasn't to found in $PATH, or the fork didn't work,
|
|
// write the error and return the error status.
|
|
static int execute_call(
|
|
t_exec_command_global *global, t_call call, const int inout[2],
|
|
char *const envp[])
|
|
{
|
|
const char **path = get_path(global->mc, envp);
|
|
pid_t pid;
|
|
const char *program_path;
|
|
|
|
program_path = search_path(global->mc, path, call.program);
|
|
if (!program_path)
|
|
return (minishell_error(str_join(fatal_error, global->mc,
|
|
"command not found: ", str_join(fatal_error, global->mc,
|
|
call.program, "\n"))), 127);
|
|
pid = fork();
|
|
if (pid < 0)
|
|
return (minishell_error("errno"), errno);
|
|
if (pid == 0)
|
|
{
|
|
if (dup2(inout[0], 0) < 0 || dup2(inout[1], 1) < 0)
|
|
return (minishell_error("errno"), errno);
|
|
close_all_pipes(global);
|
|
execve(program_path, call.argv, envp);
|
|
return (minishell_error("errno"), errno);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int create_pipes(t_exec_command_global *global, t_command command)
|
|
{
|
|
int i;
|
|
|
|
global->pipes = mem_alloc(
|
|
err_remember, global->mc, sizeof(t_pipes) * (global->nb_calls + 1));
|
|
if (err_get())
|
|
return (minishell_error("errno"), errno);
|
|
i = 0;
|
|
global->pipes[i].pipe[0] = command.input_fd;
|
|
while (++i < global->nb_calls)
|
|
if (pipe(global->pipes[i].pipe) < 0)
|
|
return (minishell_error("errno"), errno);
|
|
global->pipes[i].pipe[1] = command.output_fd;
|
|
return (0);
|
|
}
|
|
|
|
static int exec_each_call(t_exec_command_global *global,
|
|
t_command command, char *const envp[])
|
|
{
|
|
int i;
|
|
int r;
|
|
int inout[2];
|
|
|
|
i = -1;
|
|
while (++i < global->nb_calls)
|
|
{
|
|
inout[0] = global->pipes[i].pipe[0];
|
|
inout[1] = global->pipes[i + 1].pipe[1];
|
|
if (is_builtin(command.calls[i].program))
|
|
r = exec_builtin(command.calls[i]);
|
|
else
|
|
r = execute_call(global, command.calls[i], inout, envp);
|
|
if (r)
|
|
return (r);
|
|
}
|
|
return (r);
|
|
}
|
|
|
|
// FIXME line jump if command not found
|
|
int execute_command(t_env *env, t_command command)
|
|
{
|
|
t_exec_command_global global;
|
|
int r;
|
|
|
|
r = 0;
|
|
global.mc = env->mc_command;
|
|
global.nb_calls = 0;
|
|
while (command.calls[global.nb_calls].program != NULL)
|
|
global.nb_calls++;
|
|
if (global.nb_calls == 0)
|
|
return (minishell_error("no program given"), 1);
|
|
r = create_pipes(&global, command);
|
|
if (r)
|
|
return (r);
|
|
r = exec_each_call(&global, command, env->envp);
|
|
close_all_pipes(&global);
|
|
while (wait(NULL) != -1)
|
|
;
|
|
if (errno != ECHILD)
|
|
return (minishell_error("errno"), errno);
|
|
return (r);
|
|
}
|