b_final-/execute.c at main · yuhyoon/b_final- · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   execute.c                                          :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: yuhyoon <yuhyoon@student.42.gyeongsan>     +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2025/03/23 17:33:12 by yuhyoon           #+#    #+#             */
/*   Updated: 2025/03/26 14:47:58 by yuhyoon          ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include "minishell.h"

void	wait_childs(t_minish *sh)
{
	int	i;
	int	status;

	i = 0;
	while (sh->child_pids != NULL && i < sh->cmd_count)
	{
		waitpid(sh->child_pids[i], &status, 0);
		if (i == sh->cmd_count - 1)
		{
			*f_exitcode() = WEXITSTATUS(status);
			set_signal(before_readline);
		}
		i++;
	}
}

int	close_redirec_b(t_minish *sh)
{
	if (sh->save_in != STDIN_FILENO)
	{
		dup2(sh->save_in, STDIN_FILENO);
		close(sh->save_in);
		sh->save_in = STDIN_FILENO;
	}
	if (sh->save_out != STDOUT_FILENO)
	{
		dup2(sh->save_out, STDOUT_FILENO);
		close(sh->save_out);
		sh->save_out = STDOUT_FILENO;
	}
	return (0);
}

int	execute_single_builtin(int bulitin_code, t_minish *sh)
{
	int		res;
	t_ready	*rdy;

	res = -1;
	rdy = (t_ready *)(sh->ready->content);
	if (valid_redirect_builtin(rdy, sh) == NULL)
		return (-1);
	if (bulitin_code == 1)
		res = f_cd(sh, rdy);
	else if (bulitin_code == 2)
		res = f_echo(rdy);
	else if (bulitin_code == 3)
		res = f_pwd();
	else if (bulitin_code == 4)
		res = f_export(sh, rdy);
	else if (bulitin_code == 5)
		res = f_env(sh, rdy);
	else if (bulitin_code == 6)
		res = f_unset(sh, rdy);
	else if (bulitin_code == 7)
		res = f_exit(sh, rdy);
	close_redirec_b(sh);
	return (res);
}

int	execute_single_is_builtin(t_list *lst, t_minish *sh)
{
	t_ready	*rdy;
	int		bulitin_code;
	int		result;

	rdy = (t_ready *)(lst->content);
	if (rdy->cmd[0] == NULL)
		return (-1);
	bulitin_code = is_builtin(rdy->cmd[0]);
	result = bulitin_code;
	if (bulitin_code != 0)
	{
		result = execute_single_builtin(bulitin_code, sh);
		if (result == 0)
			result = bulitin_code;
		else
			result = -1;
	}
	return (result);
}

int	execute(t_minish *sh)
{
	t_list		*lst;
	t_ready		*rdy;
	int			n;

	sh->cmd_count = ft_lstsize(sh->ready);
	lst = sh->ready;
	set_signal(before_readline);
	rdy = (t_ready *)(lst->content);
	n = is_builtin(rdy->cmd[0]);
	if (n > 0 && sh->cmd_count == 1)
		execute_single_is_builtin(lst, sh);
	else
	{
		sh->child_pids = ft_calloc(sizeof(pid_t), sh->cmd_count);
		while (lst)
		{
			rdy = (t_ready *)(lst->content);
			create_process(rdy, sh);
			lst = lst->next;
		}
		wait_childs(sh);
	}
	free_minish(sh);
	return (0);
}