raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Pipeline works with invalid free(TM)

Browse source
This commit is contained in:
Maieul BOYER 2024-08-05 17:17:20 +02:00
parent dc9005218c
commit 933d68c2da
No known key found for this signature in database
6 changed files with 126 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

16
ast/src/from_node/from_node.c
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */ /* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/26 10:55:52 by rparodi #+# #+# */ /* Created: 2024/07/26 10:55:52 by rparodi #+# #+# */
/* Updated: 2024/08/04 12:43:56 by maiboyer ### ########.fr */ /* Updated: 2024/08/05 16:37:43 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -127,22 +127,22 @@ void _append_redirection(t_ast_node node, t_ast_node redirection)
return (ast_free(redirection)); return (ast_free(redirection));
if (node->kind == AST_CASE) if (node->kind == AST_CASE)
vec = &node->data.case_.suffixes_redirections; vec = &node->data.case_.suffixes_redirections;
if (node->kind == AST_COMMAND) else if (node->kind == AST_COMMAND)
vec = &node->data.command.suffixes_redirections; vec = &node->data.command.suffixes_redirections;
if (node->kind == AST_COMPOUND_STATEMENT) else if (node->kind == AST_COMPOUND_STATEMENT)
vec = &node->data.compound_statement.suffixes_redirections; vec = &node->data.compound_statement.suffixes_redirections;
if (node->kind == AST_LIST) else if (node->kind == AST_LIST)
vec = &node->data.list.suffixes_redirections; vec = &node->data.list.suffixes_redirections;
if (node->kind == AST_PIPELINE) else if (node->kind == AST_PIPELINE)
vec = &node->data.pipeline.suffixes_redirections; vec = &node->data.pipeline.suffixes_redirections;
if (node->kind == AST_SUBSHELL) else if (node->kind == AST_SUBSHELL)
vec = &node->data.subshell.suffixes_redirections; vec = &node->data.subshell.suffixes_redirections;
if (vec == NULL) else
vec = _append_scripting(node); vec = _append_scripting(node);
if (vec != NULL) if (vec != NULL)
vec_ast_push(vec, redirection); vec_ast_push(vec, redirection);
else else
ast_free(redirection); (ast_free(redirection));
} }
t_ast_terminator_kind _select_term(t_parse_node node) t_ast_terminator_kind _select_term(t_parse_node node)

10
exec/include/exec/_run_ast.h
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */ /* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/02 14:41:48 by rparodi #+# #+# */ /* Created: 2024/08/02 14:41:48 by rparodi #+# #+# */
/* Updated: 2024/08/03 15:39:10 by maiboyer ### ########.fr */ /* Updated: 2024/08/05 16:07:00 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -78,11 +78,18 @@ struct s_program_result
int exit; int exit;
}; };
typedef struct s_pipeline_result t_pipeline_result;
struct s_pipeline_result
{
int exit;
};
t_error run_arithmetic_expansion(t_ast_arithmetic_expansion *arithmetic_expansion, t_state *state, t_i64 *out); t_error run_arithmetic_expansion(t_ast_arithmetic_expansion *arithmetic_expansion, t_state *state, t_i64 *out);
t_error run_command(t_ast_command *command, t_state *state, t_cmd_pipe cmd_pipe, t_command_result *out); t_error run_command(t_ast_command *command, t_state *state, t_cmd_pipe cmd_pipe, t_command_result *out);
t_error run_expansion(t_ast_expansion *self, t_state *state, t_expansion_result *out); t_error run_expansion(t_ast_expansion *self, t_state *state, t_expansion_result *out);
t_error run_word(t_ast_word *word, t_state *state, t_word_result *out); t_error run_word(t_ast_word *word, t_state *state, t_word_result *out);
t_error run_program(t_ast_program *program, t_state *state, t_program_result *out); t_error run_program(t_ast_program *program, t_state *state, t_program_result *out);
t_error run_pipeline(t_ast_pipeline *pipeline, t_state *state, t_pipeline_result *out);
t_error run_case_(t_ast_case *case_, t_state *state, void *out); t_error run_case_(t_ast_case *case_, t_state *state, void *out);
t_error run_case_item(t_ast_case_item *case_item, t_state *state, void *out); t_error run_case_item(t_ast_case_item *case_item, t_state *state, void *out);
@ -98,7 +105,6 @@ t_error run_function_definition(t_ast_function_definition *function_definition,
t_error run_heredoc_redirection(t_ast_heredoc_redirection *heredoc_redirection, t_state *state, void *out); t_error run_heredoc_redirection(t_ast_heredoc_redirection *heredoc_redirection, t_state *state, void *out);
t_error run_if_(t_ast_if *if_, t_state *state, void *out); t_error run_if_(t_ast_if *if_, t_state *state, void *out);
t_error run_list(t_ast_list *list, t_state *state, void *out); t_error run_list(t_ast_list *list, t_state *state, void *out);
t_error run_pipeline(t_ast_pipeline *pipeline, t_state *state, void *out);
t_error run_raw_string(t_ast_raw_string *raw_string, t_state *state, void *out); t_error run_raw_string(t_ast_raw_string *raw_string, t_state *state, void *out);
t_error run_regex(t_ast_regex *regex, t_state *state, void *out); t_error run_regex(t_ast_regex *regex, t_state *state, void *out);
t_error run_subshell(t_ast_subshell *subshell, t_state *state, void *out); t_error run_subshell(t_ast_subshell *subshell, t_state *state, void *out);

189
exec/src/run_ast.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/11 17:22:29 by maiboyer #+# #+# */ /* Created: 2024/07/11 17:22:29 by maiboyer #+# #+# */
/* Updated: 2024/08/05 15:29:40 by maiboyer ### ########.fr */ /* Updated: 2024/08/05 16:55:45 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -26,6 +26,7 @@
#include "me/vec/vec_ast.h" #include "me/vec/vec_ast.h"
#include "me/vec/vec_estr.h" #include "me/vec/vec_estr.h"
#include "me/vec/vec_str.h" #include "me/vec/vec_str.h"
#include <signal.h>
#include <sys/wait.h> #include <sys/wait.h>
#include <stdio.h> #include <stdio.h>
@ -108,11 +109,17 @@ t_error _handle_len_operator(t_ast_expansion *self, t_state *state, t_expansion_
t_error _handle_no_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) t_error _handle_no_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value)
{ {
(void)(self); t_str *val;
(void)(state);
(void)(value);
if (self == NULL || state == NULL || value == NULL) if (self == NULL || state == NULL || value == NULL)
return (ERROR); return (ERROR);
val = hmap_env_get(state->tmp_var, &self->var_name);
if (val == NULL)
val = hmap_env_get(state->env, &self->var_name);
if (val == NULL)
return (value->exists = false, NO_ERROR);
value->exists = true;
value->value = *val;
return (NO_ERROR); return (NO_ERROR);
}; };
@ -275,8 +282,7 @@ t_error _ast_get_str__expansion(t_ast_node elem, t_word_iterator *state, t_vec_e
return (ERROR); return (ERROR);
if (run_expansion(&elem->data.expansion, state->state, &exp_ret)) if (run_expansion(&elem->data.expansion, state->state, &exp_ret))
return (ERROR); return (ERROR);
return (vec_estr_push(out, (t_expandable_str){.do_expand = state->res.kind == AST_WORD_NO_QUOTE, .value = str_clone(exp_ret.value)}), return (vec_estr_push(out, (t_expandable_str){.do_expand = state->res.kind == AST_WORD_NO_QUOTE, .value = exp_ret.value}), NO_ERROR);
NO_ERROR);
} }
t_error _ast_get_str__arimethic_expansion(t_ast_node elem, t_word_iterator *state, t_vec_estr *out) t_error _ast_get_str__arimethic_expansion(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
@ -327,7 +333,7 @@ t_error _exp_into_str(t_ast_node self, t_state *state, t_vec_str *append)
t_vec_str splitted; t_vec_str splitted;
t_str tmp; t_str tmp;
if (self == NULL || state == NULL || append == NULL || self->kind == AST_EXPANSION) if (self == NULL || state == NULL || append == NULL || self->kind != AST_EXPANSION)
return (ERROR); return (ERROR);
if (run_expansion(&self->data.expansion, state, &res)) if (run_expansion(&self->data.expansion, state, &res))
return (ERROR); return (ERROR);
@ -343,14 +349,14 @@ t_error _exp_into_str(t_ast_node self, t_state *state, t_vec_str *append)
t_error _arith_into_str(t_ast_node self, t_state *state, t_vec_str *append) t_error _arith_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{ {
if (self == NULL || state == NULL || append == NULL || self->kind == AST_ARITHMETIC_EXPANSION) if (self == NULL || state == NULL || append == NULL || self->kind != AST_ARITHMETIC_EXPANSION)
return (ERROR); return (ERROR);
return (NO_ERROR); return (NO_ERROR);
} }
t_error _cmd_into_str(t_ast_node self, t_state *state, t_vec_str *append) t_error _cmd_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{ {
if (self == NULL || state == NULL || append == NULL || self->kind == AST_COMMAND_SUBSTITUTION) if (self == NULL || state == NULL || append == NULL || self->kind != AST_COMMAND_SUBSTITUTION)
return (ERROR); return (ERROR);
/* /*
if (str_split(res.value, _get_ifs_value(state), &splitted)) if (str_split(res.value, _get_ifs_value(state), &splitted))
@ -459,9 +465,10 @@ t_error _ast_into_str(t_ast_node self, t_state *state, t_vec_str *append)
// End Internals funcs // End Internals funcs
t_error run_expansion(t_ast_expansion *self, t_state *state, t_expansion_result *out); // These are done externally
t_error run_word(t_ast_word *word, t_state *state, t_word_result *out); // t_error run_file_redirection(t_ast_file_redirection *file_redirection, t_state *state, void *out) NOT_DONE;
t_error run_arithmetic_expansion(t_ast_arithmetic_expansion *arithmetic_expansion, t_state *state, t_i64 *out); // t_error run_heredoc_redirection(t_ast_heredoc_redirection *heredoc_redirection, t_state *state, void *out) NOT_DONE;
// t_error run_raw_string(t_ast_raw_string *raw_string, t_state *state, void *out) NOT_DONE;
t_error run_case_(t_ast_case *case_, t_state *state, void *out) NOT_DONE; t_error run_case_(t_ast_case *case_, t_state *state, void *out) NOT_DONE;
t_error run_case_item(t_ast_case_item *case_item, t_state *state, void *out) NOT_DONE; t_error run_case_item(t_ast_case_item *case_item, t_state *state, void *out) NOT_DONE;
@ -471,26 +478,87 @@ t_error run_elif(t_ast_elif *elif, t_state *state, void *out) NOT_DONE;
t_error run_else_(t_ast_else *else_, t_state *state, void *out) NOT_DONE; t_error run_else_(t_ast_else *else_, t_state *state, void *out) NOT_DONE;
t_error run_empty(t_ast_empty *empty, t_state *state, void *out) NOT_DONE; t_error run_empty(t_ast_empty *empty, t_state *state, void *out) NOT_DONE;
t_error run_extglob(t_ast_extglob *extglob, t_state *state, void *out) NOT_DONE; t_error run_extglob(t_ast_extglob *extglob, t_state *state, void *out) NOT_DONE;
t_error run_file_redirection(t_ast_file_redirection *file_redirection, t_state *state, void *out) NOT_DONE;
t_error run_for_(t_ast_for *for_, t_state *state, void *out) NOT_DONE; t_error run_for_(t_ast_for *for_, t_state *state, void *out) NOT_DONE;
t_error run_function_definition(t_ast_function_definition *function_definition, t_state *state, void *out) NOT_DONE; t_error run_function_definition(t_ast_function_definition *function_definition, t_state *state, void *out) NOT_DONE;
t_error run_heredoc_redirection(t_ast_heredoc_redirection *heredoc_redirection, t_state *state, void *out) NOT_DONE;
t_error run_if_(t_ast_if *if_, t_state *state, void *out) NOT_DONE; t_error run_if_(t_ast_if *if_, t_state *state, void *out) NOT_DONE;
t_error run_list(t_ast_list *list, t_state *state, void *out) NOT_DONE; t_error run_list(t_ast_list *list, t_state *state, void *out) NOT_DONE;
t_error run_pipeline(t_ast_pipeline *pipeline, t_state *state, void *out) NOT_DONE;
t_error run_raw_string(t_ast_raw_string *raw_string, t_state *state, void *out) NOT_DONE;
t_error run_regex(t_ast_regex *regex, t_state *state, void *out) NOT_DONE; t_error run_regex(t_ast_regex *regex, t_state *state, void *out) NOT_DONE;
t_error run_subshell(t_ast_subshell *subshell, t_state *state, void *out) NOT_DONE; t_error run_subshell(t_ast_subshell *subshell, t_state *state, void *out) NOT_DONE;
t_error run_until(t_ast_until *until, t_state *state, void *out) NOT_DONE; t_error run_until(t_ast_until *until, t_state *state, void *out) NOT_DONE;
t_error run_variable_assignment(t_ast_variable_assignment *variable_assignment, t_state *state, bool is_temporary, void *out) NOT_DONE; t_error run_variable_assignment(t_ast_variable_assignment *variable_assignment, t_state *state, bool is_temporary, void *out) NOT_DONE;
t_error run_while_(t_ast_while *while_, t_state *state, void *out) NOT_DONE; t_error run_while_(t_ast_while *while_, t_state *state, void *out) NOT_DONE;
t_error run_pipeline(t_ast_pipeline *pipeline, t_state *state, t_pipeline_result *out)
{
t_usize i;
t_cmd_pipe cmd_pipe;
t_ast_node child;
t_error ret;
t_command_result cmd_result;
t_ast_node tmp_ast;
if (pipeline == NULL || state == NULL || out == NULL)
return (ERROR);
i = 0;
cmd_pipe.input = NULL;
cmd_pipe.create_output = true;
while (i < pipeline->statements.len - 1)
{
child = pipeline->statements.buffer[i];
if (child->kind == AST_COMMAND)
{
if (run_command(&child->data.command, state, cmd_pipe, &cmd_result))
{
cmd_pipe.input = NULL;
ret = ERROR;
}
else
{
if (cmd_result.process.stdout != NULL)
cmd_pipe.input = cmd_result.process.stdout;
else
(printf("WTF ???\n"));
if (cmd_result.process.stdin != NULL)
close_fd(cmd_result.process.stdin);
if (cmd_result.process.stderr != NULL)
close_fd(cmd_result.process.stderr);
}
}
i++;
}
{
cmd_pipe.create_output = false;
child = pipeline->statements.buffer[i];
if (child->kind == AST_COMMAND)
{
while (!vec_ast_pop_front(&pipeline->suffixes_redirections, &tmp_ast))
vec_ast_push(&child->data.command.suffixes_redirections, tmp_ast);
if (run_command(&child->data.command, state, cmd_pipe, &cmd_result))
{
ret = ERROR;
}
else
{
out->exit = cmd_result.exit;
if (cmd_result.process.stdout != NULL)
close_fd(cmd_result.process.stdout);
if (cmd_result.process.stdin != NULL)
close_fd(cmd_result.process.stdin);
if (cmd_result.process.stderr != NULL)
close_fd(cmd_result.process.stderr);
}
}
}
return (ret);
}
t_error run_program(t_ast_program *self, t_state *state, t_program_result *out) t_error run_program(t_ast_program *self, t_state *state, t_program_result *out)
{ {
t_usize i; t_usize i;
t_ast_node child; t_ast_node child;
t_command_result cmd_result; t_command_result cmd_result;
t_pipeline_result pipeline_result;
if (self == NULL || state == NULL || out == NULL) if (self == NULL || state == NULL || out == NULL)
return (ERROR); return (ERROR);
@ -510,8 +578,11 @@ t_error run_program(t_ast_program *self, t_state *state, t_program_result *out)
if (cmd_result.process.stderr != NULL) if (cmd_result.process.stderr != NULL)
close_fd(cmd_result.process.stderr); close_fd(cmd_result.process.stderr);
} }
else if (child->kind == AST_IF) else if (child->kind == AST_PIPELINE)
; {
if (run_pipeline(&child->data.pipeline, state, &pipeline_result))
return (out->exit = 127, ERROR);
}
else else
; ;
i++; i++;
@ -574,7 +645,6 @@ t_error _handle_builtin(t_spawn_info info, t_state *state)
return (ERROR); return (ERROR);
} }
t_error _spawn_cmd_and_run(t_vec_str args, t_vec_ast redirection, t_state *state, t_cmd_pipe cmd_pipe, t_command_result *out) t_error _spawn_cmd_and_run(t_vec_str args, t_vec_ast redirection, t_state *state, t_cmd_pipe cmd_pipe, t_command_result *out)
{ {
t_spawn_info info; t_spawn_info info;
@ -585,8 +655,10 @@ t_error _spawn_cmd_and_run(t_vec_str args, t_vec_ast redirection, t_state *state
struct s_ffree_state ffree; struct s_ffree_state ffree;
info = (t_spawn_info){}; info = (t_spawn_info){};
if (cmd_pipe.input) if (cmd_pipe.input != NULL)
info.stdin = fd(cmd_pipe.input); info.stdin = fd(cmd_pipe.input);
if (cmd_pipe.input != NULL && !(cmd_pipe.input->perms & FD_READ))
printf("PERMISSION ERROR for %s !\n", cmd_pipe.input->name);
if (cmd_pipe.create_output) if (cmd_pipe.create_output)
info.stdout = piped(); info.stdout = piped();
i = 0; i = 0;
@ -682,6 +754,8 @@ t_error _spawn_cmd_and_run(t_vec_str args, t_vec_ast redirection, t_state *state
info.binary_path = str_clone(info.arguments.buffer[0]); info.binary_path = str_clone(info.arguments.buffer[0]);
info.forked_free_args = &ffree; info.forked_free_args = &ffree;
info.forked_free = (void (*)(void *))_ffree_func; info.forked_free = (void (*)(void *))_ffree_func;
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
if (spawn_process(info, &out->process)) if (spawn_process(info, &out->process))
return (ERROR); return (ERROR);
int status; int status;
@ -732,7 +806,7 @@ t_error run_command(t_ast_command *command, t_state *state, t_cmd_pipe cmd_pipe,
if (tmp->kind == AST_VARIABLE_ASSIGNMENT) if (tmp->kind == AST_VARIABLE_ASSIGNMENT)
{ {
if (run_variable_assignment(&tmp->data.variable_assignment, state, true, NULL)) if (run_variable_assignment(&tmp->data.variable_assignment, state, true, NULL))
return (ERROR); return (vec_str_free(args), vec_ast_free(redirection), ERROR);
} }
i++; i++;
} }
@ -740,19 +814,19 @@ t_error run_command(t_ast_command *command, t_state *state, t_cmd_pipe cmd_pipe,
while (i < command->cmd_word.len) while (i < command->cmd_word.len)
{ {
if (_ast_into_str(command->cmd_word.buffer[i], state, &args)) if (_ast_into_str(command->cmd_word.buffer[i], state, &args))
return (ERROR); return (vec_str_free(args), vec_ast_free(redirection), ERROR);
i++; i++;
} }
while (i < command->prefixes.len) i = 0;
while (i < command->suffixes_redirections.len)
{ {
tmp = command->prefixes.buffer[i]; tmp = command->suffixes_redirections.buffer[i];
if (tmp->kind == AST_FILE_REDIRECTION || tmp->kind == AST_HEREDOC_REDIRECTION) if (tmp->kind == AST_FILE_REDIRECTION || tmp->kind == AST_HEREDOC_REDIRECTION)
vec_ast_push(&redirection, tmp); vec_ast_push(&redirection, tmp);
i++; i++;
} }
i = 0;
if (_spawn_cmd_and_run(args, redirection, state, cmd_pipe, out)) if (_spawn_cmd_and_run(args, redirection, state, cmd_pipe, out))
return (ERROR); return (vec_str_free(args), vec_ast_free(redirection), ERROR);
return (NO_ERROR); return (NO_ERROR);
} }
@ -774,66 +848,3 @@ t_error run_word(t_ast_word *word, t_state *state, t_word_result *out)
return (vec_estr_free(iter_state.res.value), ERROR); return (vec_estr_free(iter_state.res.value), ERROR);
return (*out = iter_state.res, NO_ERROR); return (*out = iter_state.res, NO_ERROR);
} }
// FUNCTIONS
/*
t_error run_node(t_ast_node self, t_state *state, void *out)
{
if (self->kind == AST_ARITHMETIC_EXPANSION)
return (run_arithmetic_expansion(&self->data.arithmetic_expansion, state, out));
if (self->kind == AST_CASE)
return (run_case_(&self->data.case_, state, out));
if (self->kind == AST_CASE_ITEM)
return (run_case_item(&self->data.case_item, state, out));
if (self->kind == AST_COMMAND)
return (run_command(&self->data.command, state, out));
if (self->kind == AST_COMMAND_SUBSTITUTION)
return (run_command_substitution(&self->data.command_substitution, state, out));
if (self->kind == AST_COMPOUND_STATEMENT)
return (run_compound_statement(&self->data.compound_statement, state, out));
if (self->kind == AST_ELIF)
return (run_elif(&self->data.elif, state, out));
if (self->kind == AST_ELSE)
return (run_else_(&self->data.else_, state, out));
if (self->kind == AST_EMPTY)
return (run_empty(&self->data.empty, state, out));
if (self->kind == AST_EXPANSION)
return (run_expansion(&self->data.expansion, state, out));
if (self->kind == AST_EXTGLOB)
return (run_extglob(&self->data.extglob, state, out));
if (self->kind == AST_FILE_REDIRECTION)
return (run_file_redirection(&self->data.file_redirection, state, out));
if (self->kind == AST_FOR)
return (run_for_(&self->data.for_, state, out));
if (self->kind == AST_FUNCTION_DEFINITION)
return (run_function_definition(&self->data.function_definition, state, out));
if (self->kind == AST_HEREDOC_REDIRECTION)
return (run_heredoc_redirection(&self->data.heredoc_redirection, state, out));
if (self->kind == AST_IF)
return (run_if_(&self->data.if_, state, out));
if (self->kind == AST_LIST)
return (run_list(&self->data.list, state, out));
if (self->kind == AST_PIPELINE)
return (run_pipeline(&self->data.pipeline, state, out));
if (self->kind == AST_PROGRAM)
return (run_program(&self->data.program, state, out));
if (self->kind == AST_RAW_STRING)
return (run_raw_string(&self->data.raw_string, state, out));
if (self->kind == AST_REGEX)
return (run_regex(&self->data.regex, state, out));
if (self->kind == AST_SUBSHELL)
return (run_subshell(&self->data.subshell, state, out));
if (self->kind == AST_UNTIL)
return (run_until(&self->data.until, state, out));
if (self->kind == AST_VARIABLE_ASSIGNMENT)
return (run_variable_assignment(&self->data.variable_assignment, state, out));
if (self->kind == AST_WHILE)
return (run_while_(&self->data.while_, state, out));
if (self->kind == AST_WORD)
return (run_word(&self->data.word, state, out));
return (ERROR);
}
*/

4
stdme/src/fs/file_dup.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/01 06:59:44 by maiboyer #+# #+# */ /* Created: 2024/08/01 06:59:44 by maiboyer #+# #+# */
/* Updated: 2024/08/01 07:03:32 by maiboyer ### ########.fr */ /* Updated: 2024/08/05 17:01:40 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -27,7 +27,7 @@ t_fd *dup_fd(t_fd *fd)
return (NULL); return (NULL);
tmp = dup(fd->fd); tmp = dup(fd->fd);
if (tmp == -1) if (tmp == -1)
return (NULL); return (printf("There was an error while duping the fd %d `%s`\n", fd->fd, fd->name), NULL);
slot->ty = SLOT_FD; slot->ty = SLOT_FD;
slot->slot.fd.fd = tmp; slot->slot.fd.fd = tmp;
slot->slot.fd.perms = fd->perms; slot->slot.fd.perms = fd->perms;

4
stdme/src/os/pipe.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/04 17:59:48 by maiboyer #+# #+# */ /* Created: 2024/01/04 17:59:48 by maiboyer #+# #+# */
/* Updated: 2024/08/01 06:56:14 by maiboyer ### ########.fr */ /* Updated: 2024/08/05 17:08:14 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -43,7 +43,7 @@ t_error create_pipe(t_pipe *out)
return (ERROR); return (ERROR);
} }
read->slot.fd.fd = fd[0]; read->slot.fd.fd = fd[0];
write->slot.fd.fd = fd[0]; write->slot.fd.fd = fd[1];
read->slot.fd.type = FD_PIPE; read->slot.fd.type = FD_PIPE;
write->slot.fd.type = FD_PIPE; write->slot.fd.type = FD_PIPE;
read->slot.fd.perms = FD_READ; read->slot.fd.perms = FD_READ;

5
stdme/src/os/process.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/03 16:22:41 by maiboyer #+# #+# */ /* Created: 2024/01/03 16:22:41 by maiboyer #+# #+# */
/* Updated: 2024/08/03 16:34:46 by maiboyer ### ########.fr */ /* Updated: 2024/08/05 15:46:09 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -17,6 +17,7 @@
#include "me/string/string.h" #include "me/string/string.h"
#include "me/types.h" #include "me/types.h"
#include "me/vec/vec_str.h" #include "me/vec/vec_str.h"
#include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
@ -29,6 +30,8 @@ t_error spawn_process_exec(t_spawn_info info, t_process *process)
{ {
if (info.forked_free) if (info.forked_free)
info.forked_free(info.forked_free_args); info.forked_free(info.forked_free_args);
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
dup2(info.stdin.fd.fd->fd, 0); dup2(info.stdin.fd.fd->fd, 0);
dup2(info.stdout.fd.fd->fd, 1); dup2(info.stdout.fd.fd->fd, 1);
dup2(info.stderr.fd.fd->fd, 2); dup2(info.stderr.fd.fd->fd, 2);