shell.c

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <dirent.h>
#include <sys/stat.h>
#include <limits.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>

char *find_executeable(const char *name) {
    char *path = getenv("PATH");
    if (!path) return NULL;

    char *path_copy = strdup(path);
    char *dir = strtok(path_copy, ":");

    while (dir != NULL) {
        char full_path[PATH_MAX];
        snprintf(full_path, sizeof(full_path), "%s/%s", dir, name);

        struct stat st;
        if (stat(full_path, &st) == 0 &&
                S_ISREG(st.st_mode) &&
                (st.st_mode & S_IXUSR)) {
            free(path_copy);
            return strdup(full_path);
        }

        dir = strtok(NULL, ":");
    }
    free(path_copy);
    return NULL;
}

char **parse_command(char *line, int *argc) {
    char **argv = malloc(64 * sizeof(char *));
    if (!argv) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    char token[1024];
    int tlen = 0;

    bool in_single = false;
    bool in_double = false;

    *argc = 0;

    for (int i = 0;; i++) {
        char c = line[i];

        if (c == '\0') {
            if (tlen > 0) {
                token[tlen] = '\0';
                argv[(*argc)++] = strdup(token);
            }
            break;
        }

        if ((!in_single && !in_double && c == '\\') || (in_double && c == '\\')) {
            i++;
            c = line[i];
            if (c == '\0') break;
            token[tlen++] = c;
            continue;
        }

        if (!in_single && !in_double && (c == ' ' || c == '\t')) {
            if (tlen > 0) {
                token[tlen] = '\0';
                argv[(*argc)++] = strdup(token);
                tlen = 0;
            }
            continue;
        }

        if (!in_double && c == '\'') {
            in_single = !in_single;
            continue;
        }

        if (!in_single && c == '"') {
            in_double = !in_double;
            continue;
        }

        token[tlen++] = c;
    }

    argv[*argc] = NULL;
    return argv;
}

bool execute_builtin(int argc, char **argv)
{
    if (strcmp(argv[0], "exit") == 0) {
        exit(0);
    }

    if (strcmp(argv[0], "cd") == 0) {
        const char *path;
        if (argc < 2) {
            path = getenv("HOME");
            if (!path) {
                fprintf(stderr, "cd: HOME not set\n");
                return true;
            }
        } else {
            if (strcmp(argv[1], "~") == 0) {
                path = getenv("HOME");
                
                if (!path) {
                    fprintf(stderr, "cd: HOME not set\n");
                    return true;
                }
            } else {
                path = argv[1];
            }
        }

        if (chdir(path) != 0) {
            switch (errno) {
                case ENOENT:
                    fprintf(stderr, "cd: %s: No such file or directory\n", path);
                    break;
                case EACCES:
                    fprintf(stderr, "cd: %s: Permission denied\n", path);
                    break;
                default:
                    perror("cd");
            }
        }
        return true;
    }

    if (strcmp(argv[0], "pwd") == 0) {
        char path[PATH_MAX];
        if (getcwd(path, sizeof(path)) != NULL) {
            printf("%s\n", path);
        } else {
            perror("pwd");
        }
        return true;
    }

    if (strcmp(argv[0], "echo") == 0) {
        for (int i = 1; i < argc; i++) {
            printf("%s", argv[i]);

            if (i != argc - 1)
                printf(" ");
        }

        printf("\n");
        return true;
    }

    if (strcmp(argv[0], "type") == 0) {

        if (argc < 2) {
            printf("type: missing argument\n");
            return true;
        }

        const char *builtins[] = {
            "exit",
            "echo",
            "type",
            "pwd",
            "cd"
        };

        size_t builtinLen = sizeof(builtins) / sizeof(builtins[0]);

        for (size_t i = 0; i < builtinLen; i++) {
            if (strcmp(argv[1], builtins[i]) == 0) {
                printf("%s is a shell builtin\n", argv[1]);
                return true;
            }
        }

        char *exe = find_executeable(argv[1]);

        if (exe) {
            printf("%s\n", exe);
            free(exe);
        } else {
            printf("%s: not found\n", argv[1]);
        }

        return true;
    }

    return false;
}

void execute_external(char **argv)
{
    pid_t pid = fork();

    if (pid == 0) {

        execvp(argv[0], argv);

        fprintf(stderr, "%s: command not found\n", argv[0]);
        exit(EXIT_FAILURE);

    } else if (pid > 0) {

        waitpid(pid, NULL, 0);

    } else {

        perror("fork");

    }
}

int main(void) {
  setbuf(stdout, NULL);

  while (1) {

      printf("$ ");
      
      char line[1024];
      if (!fgets(line, sizeof(line), stdin))
          break;

      line[strcspn(line, "\n")] = '\0';

      int argc;
      char **argv = parse_command(line, &argc);

      char *redirect_file = NULL;

      int redirect_target = -1;
      bool append = false;

      for (int i = 0; i < argc; i++) {
          if (strcmp(argv[i], ">") == 0 
           || strcmp(argv[i], "1>") == 0 
           || strcmp(argv[i], "2>") == 0
           || strcmp(argv[i], ">>") == 0
           || strcmp(argv[i], "1>>") == 0
           || strcmp(argv[i], "2>>") == 0) {
              if (strcmp(argv[i], ">") == 0 || strcmp(argv[i], "1>") == 0) redirect_target = STDOUT_FILENO;
              if (strcmp(argv[i], "2>") == 0) redirect_target = STDERR_FILENO;
              if (strcmp(argv[i], "2>>") == 0) {
                  redirect_target = STDERR_FILENO;
                  append = true;
              }
              if (strcmp(argv[i], ">>") == 0 || strcmp(argv[i], "1>>") == 0) {
                  redirect_target = STDOUT_FILENO;
                  append = true;
              }
              redirect_file = argv[i + 1];
              argv[i] = NULL;
              argc = i;
              break;
          }
      }

      if (argc == 0) {
          for (int i = 0; i < argc; i++)
              free(argv[i]);
          free(argv);
          continue;
      }

      int saved_fd = -1;
      if (redirect_file) {
          saved_fd = dup(redirect_target);
          int flags = append ? O_WRONLY | O_CREAT | O_APPEND
                             : O_WRONLY | O_CREAT | O_TRUNC;
          int redirect_fd = open(redirect_file, flags, 0644);
          dup2(redirect_fd, redirect_target);
          close(redirect_fd);
      }

      if (!execute_builtin(argc, argv))
          execute_external(argv);

      if (redirect_file) {
          dup2(saved_fd, redirect_target);
          close(saved_fd);
      }

      free(argv);
  }
  return 0;
}