builtin.c

#include "builtin.h"
#include <limits.h>
#include "utils.h"
#include "parsing.h"
#include "freecmd.h"
#include "exec.h"

static const int EXECUTED = (int) true, NOT_EXECUTED = (int) false;

static const char EXIT_CMD_STR[] = "exit";
static const int LEN_EXIT_CMD_STR = 5;

static const char CD_CMD_STR[] = "cd";
static const int LEN_CD_CMD_STR = 3;

static const char PWD_CMD_STR[] = "pwd";
static const int LEN_PWD_CMD_STR = 4;

static const char HISTORY_CMD_STR[] = "history";
static const int LEN_HISTORY_CMD_STR = 8;

#ifndef SHELL_NO_INTERACTIVE
static const int HISTORY_OPTIONAL_PARAM_COUNT = 1;
static const int HISTORY_LAST_NTH_AMOUNT_POS = 1;
#endif

// returns true if the 'exit' call
// should be performed
//
// (It must not be called from here)
int
exit_shell(char *cmd, int *status)
{
	if (strncmp(cmd, EXIT_CMD_STR, LEN_EXIT_CMD_STR) != 0) {
		return NOT_EXECUTED;
	}

	*status = EXIT_SUCCESS;
	return EXECUTED;
}

/*
 * Returns true if the `cmd` string starts with `CD_CMD_STR`. Returns false otherwise
 */
static bool
is_cd_command(char *cmd)
{
	int cmd_len = strlen(cmd);
	int max_iter = MIN(LEN_CD_CMD_STR - 1, cmd_len);
	int i = 0;
	for (i = 0; i < max_iter; i++) {
		if (cmd[i] != CD_CMD_STR[i]) {
			return false;
		}
	}

	if (i <= cmd_len && i >= LEN_CD_CMD_STR - 1) {
		return cmd[i] == END_STRING || cmd[i] == SPACE;
	}

	return false;
}

/*
 * Returns true if the string `path` has at least a character that is not a
 * space character. Returns false otherwise
 */
static bool
is_non_empty(char *path)
{
	int max_iter = MIN(PATH_MAX, strlen(path));

	for (int i = 0; i < max_iter; i++) {
		if (path[i] != SPACE) {
			return true;
		}
	}

	return false;
}

// returns true if "chdir" was performed
//  this means that if 'cmd' contains:
// 	1. $ cd directory (change to 'directory')
// 	2. $ cd (change to $HOME)
//  it has to be executed and then return true
//
//  Remember to update the 'prompt' with the
//  	new directory.
//
// Examples:
//  1. cmd = ['c','d', ' ', '/', 'b', 'i', 'n', '\0']
//  2. cmd = ['c','d', '\0']
int
cd(char *cmd, char *prompt, int *status)
{
	if (!is_cd_command(cmd)) {
		return NOT_EXECUTED;
	}

	char dest_path[PATH_MAX] = { END_STRING };
	char *temp_path = strchr(cmd, SPACE);

	if (temp_path != NULL && is_non_empty(temp_path)) {
		strncpy(dest_path, temp_path + 1, PATH_MAX - 1);

	} else {
		char *home_path = getenv(HOME_ENV_VAR_KEY);
		if (home_path == NULL) {
			perror("Error while retrieving home path");
			*status = EXIT_FAILURE;
			return EXECUTED;
		}
		strncpy(dest_path, home_path, PATH_MAX - 1);
	}

	char full_rest_path[PATH_MAX] = { END_STRING };
	char *res = realpath(dest_path, full_rest_path);
	if (res == NULL) {
		perror("Error while retrieving realpath");
		*status = EXIT_FAILURE;
		return EXECUTED;
	}

	int _res = chdir(full_rest_path);
	if (_res == GENERIC_ERROR_CODE) {
		perror("Error while changing directory");
		*status = EXIT_FAILURE;
		return EXECUTED;
	}

	update_prompt(prompt, full_rest_path);
	*status = EXIT_SUCCESS;

	return EXECUTED;
}

// returns true if 'pwd' was invoked
// in the command line
//
// (It has to be executed here and then
// 	return true)
int
pwd(char *cmd, int *status)
{
	if (strncmp(cmd, PWD_CMD_STR, LEN_PWD_CMD_STR) != 0) {
		return NOT_EXECUTED;
	}

	char cwd_path[PATH_MAX] = { END_STRING };

	char *res = getcwd(cwd_path, PATH_MAX);
	if (res == NULL) {
		perror("Error while executing pwd");
		*status = EXIT_FAILURE;
		return EXECUTED;
	}

	printf("%s\n", cwd_path);
	*status = EXIT_SUCCESS;

	return EXECUTED;
}

static bool
is_history_command(char *cmd)
{
	int cmd_len = strlen(cmd);
	int max_iter = MIN(LEN_HISTORY_CMD_STR - 1, cmd_len);
	int i = 0;
	for (i = 0; i < max_iter; i++) {
		if (cmd[i] != HISTORY_CMD_STR[i]) {
			return false;
		}
	}

	if (i <= cmd_len && i >= LEN_HISTORY_CMD_STR - 1) {
		return cmd[i] == END_STRING || cmd[i] == SPACE;
	}

	return false;
}

// returns true if `history` was invoked
// in the command line
//
// (It has to be executed here and then
// 	return true)
int
history(char *cmd, int *status, history_data_t *history)
{
#ifndef SHELL_NO_INTERACTIVE
	struct cmd *parsed_cmd;
	parsed_cmd = parse_line(cmd, status);

	if (parsed_cmd->type != EXEC) {
		free_command(parsed_cmd);
		return NOT_EXECUTED;
	}
	struct execcmd *history_cmd = (struct execcmd *) parsed_cmd;

	if (!is_history_command(history_cmd->argv[0])) {
		free_command(parsed_cmd);
		return NOT_EXECUTED;
	}

	if (history_cmd->argc > HISTORY_OPTIONAL_PARAM_COUNT + 1) {
		perror("Error at calling history command. Expected: history "
		       "[n]");
		free_command(parsed_cmd);
		return EXECUTED;
	}

	set_environ_vars(history_cmd->eargv, history_cmd->eargc);

	if (history_cmd->argc == HISTORY_OPTIONAL_PARAM_COUNT + 1) {
		int n = atoi(history_cmd->argv[HISTORY_LAST_NTH_AMOUNT_POS]);
		history_print_last_n(history, n, status);
	} else {
		history_print_all(history, status);
	}

	free_command(parsed_cmd);
	return EXECUTED;
#else
	MARK_UNUSED_ALWAYS(cmd);
	MARK_UNUSED_ALWAYS(status);
	MARK_UNUSED_ALWAYS(history);
	MARK_UNUSED_ALWAYS(is_history_command);
	return NOT_EXECUTED;
#endif
}