1
// mysh - a simple Unix shell
2

3
#include <stdio.h>
4
#include <stdlib.h>
5
#include <string.h>
6
#include <unistd.h>
7
#include <sys/types.h>
8
#include <sys/wait.h>
9
#include <fcntl.h>
10
#include <signal.h>
11
#include <stdbool.h>
12

13
int main(void) {
14
    char line[1024];
15
    char *result;
16

17
    char *args[64];
18
    int arg_count;
19

20
    while(true) {
21
        printf("mysh> ");
22
        fflush(stdout);
23
        result = fgets(line, sizeof(line), stdin);
24

25
        if(result == NULL) {
26
            printf("\n");
27
            break;
28
        } else {
29
            // This section records and parses the user input command.
30
            char *newline = strchr(line, '\n');
31
            if(newline) { *newline = '\0'; }
32

33
            arg_count = 0;
34
            args[arg_count] = strtok(line, " ");
35

36
            while (args[arg_count] != NULL) {
37
                arg_count++;
38
                args[arg_count] = strtok(NULL, " ");
39
            }
40

41
            if(arg_count == 0) { continue; }
42
            for(int i = 0; i < arg_count; i++) {
43
                printf("Token %d: %s\n", i, args[i]);
44
            }
45

46
            // This section handles the Built-In "cd" command.
47
            if(strcmp(args[0], "cd") == 0) {
48
                if(args[1] == NULL) {
49
                    chdir(getenv("HOME"));
50
                } else {
51
                    int cd_result = chdir(args[1]);
52
                    if(cd_result == -1) { perror("cd failed"); }
53
                }
54
                continue;
55
            }
56

57
            // This section handles the Built-In "ext" command.
58
            if(strcmp(args[0], "exit") == 0) { exit(0); }
59

60
            // This section checks for input redirection, output redirection, or piping.
61
            char *filename;
62
            int redirect_cmd = 0;
63

64
            char **pipe_left = NULL;
65
            char **pipe_right = NULL;
66

67
            for(int i = 0; i < arg_count; i++) {
68
                if(strcmp(args[i], ">") == 0) {
69
                    filename = args[i + 1];
70
                    redirect_cmd = 1;
71
                    args[i] = NULL;
72
                    break;
73
                } else if (strcmp(args[i], "<") == 0) {
74
                    filename = args[i + 1];
75
                    redirect_cmd = 2;
76
                    args[i] = NULL;
77
                    break;
78
                } else if (strcmp(args[i], "|") == 0) {
79
                    redirect_cmd = 3;
80
                    args[i] = NULL;
81

82
                    pipe_left = args;
83
                    pipe_right = &args[i + 1];
84
                    break;
85
                }
86
            }
87

88
            // This section runs if a pipe is detected.
89
            if(redirect_cmd == 3) {
90
                int pipefd[2];
91
                pid_t pid1, pid2;
92

93
                if (pipe(pipefd) == -1) {
94
                    perror("pipe");
95
                    exit(1);
96
                }
97

98
                // Fork Firct child.
99
                pid1 = fork();
100
                if (pid1 == 0) {
101
                    dup2(pipefd[1], STDOUT_FILENO);
102
                    close(pipefd[0]);
103
                    close(pipefd[1]);
104

105
                    execvp(pipe_left[0], pipe_left);
106
                    perror("execvp left");
107
                    exit(1);
108
                } else if(pid1 < 0) {
109
                    perror("fork failed");
110
                }
111

112
                // Fork Second child.
113
                pid2 = fork();
114
                if (pid2 == 0) {
115
                    dup2(pipefd[0], STDIN_FILENO);
116
                    close(pipefd[0]);
117
                    close(pipefd[1]);
118

119
                    execvp(pipe_right[0], pipe_right);
120
                    perror("execvp right");
121
                    exit(1);
122
                } else if(pid2 < 0) {
123
                    perror("fork failed");
124
                }
125

126
                // This is the parent cleanup section in the pipe process.
127
                close(pipefd[0]);
128
                close(pipefd[1]);
129

130
                waitpid(pid1, NULL, 0);
131
                waitpid(pid2, NULL, 0);
132
                continue; // Continues here to prevent the normal fork from running.
133
            }
134

135
            // This normal fork here is ran if a pipe is not detected. It accounts for input redirection and output redirection.
136
            pid_t pid = fork();
137
            if(pid == 0) {
138
                if(redirect_cmd == 1) {
139
                    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
140
                    if(fd == -1) {
141
                        perror("execvp failed");
142
                        exit(1);
143
                    }
144

145
                    dup2(fd, STDOUT_FILENO);
146
                    close(fd);
147
                } else if(redirect_cmd == 2) {
148
                    int fd = open(filename, O_RDONLY);
149
                    if(fd == -1) {
150
                        perror("execvp failed");
151
                        exit(1);
152
                    }
153

154
                    dup2(fd, STDIN_FILENO);
155
                    close(fd);
156
                }
157

158
                execvp(args[0], args);
159
                perror("execvp failed");
160
                exit(1);
161
            } else if(pid > 0) {
162
                waitpid(pid, NULL, 0);
163
            } else {
164
                perror("fork failed");
165
            }
166
        }
167
    }
168
    return 0;
169
}