tvdu29/minishell
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Dev (#2)

Browse Source 
* Restart from scratch

branched out on dev
removed all previous source files
started test on new env2lst function

* norm: splitted functions in main into appropriate file

Moved lstdelenvelem & env2lst to ms_env.c
Normed out files

* Feat(WIP): Added possibility to cmd_env to execute commands with
altered env.

Added dummy function for cd, echo, setenv & unsetenv
Started work on env copy feature

* feature: switched env from ft_list to specific list

* feature: added execution of commands from path

* feature: added env, setenv & unsetenv builtins

added -i option & command execution to env
added setenv & unsetenv builtins

* Clean-up: normed out files

* Changed comportment on error for check_path functions

* feature: added completion for ~ and ${}

WIP leaks detected on ${} completion

* fix leak on  ext need test

* feature: added echo cmd

changed printf ref to ft_printf

* feature: add cd built-in

* Simple norm-out

* moved env functions to libft

* fixed out-of-memory access in extension

* Resolved infinite loop in extension revolving

WIP norming in cd

* Normedout cmd_cd.c

* Normed out functions in cmd_cd

* Normed out funtions

sorting out needed

* removed -fsanitize from Makefile

* corrected env -i crash & SHLVL

* Delete norm.txt

* added put_error_cd2 in put_error_cd.c

* added inline environment
This commit is contained in:
tvdu29
2020-01-31 15:06:17 +01:00
committed by GitHub
parent 5247e0d8e6
commit 2a2f5bd4d3
146 changed files with 5802 additions and 772 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
srcs/cmd_cd.c
View File

@@ -6,101 +6,68 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/07 16:44:40 by tmaze #+# #+# */
/* Updated: 2019/01/30 17:02:05 by tmaze ### ########.fr */
/* Updated: 2020/01/26 22:17:48 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
void put_error_cd(char *file, char *msg)
{
ft_putstr("cd: ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
}
char *check_path_slash_cd(char *exec)
{
int i;
struct stat info;
struct stat info2;
if (exec[0] == '/')
{
if ((i = access(exec, F_OK)) != 0)
put_error_cd(exec, "no such file or directory");
if (i != 0)
return (NULL);
if ((i = stat(exec, &info)) != 0)
put_error_cd(exec, "can't determine info");
if (i != 0)
return (NULL);
if (!S_ISDIR(info.st_mode))
{
put_error_cd(exec, "not a directory");
return (NULL);
}
return (put_error_cd(exec, "no such file or directory"));
if ((i = lstat(exec, &info)) != 0)
return (put_error_cd(exec, "can't determine info"));
if ((S_ISLNK(info.st_mode)
&& ((i = stat(exec, &info2)) != 0 || !S_ISDIR(info2.st_mode)))
&& !S_ISDIR(info.st_mode))
return (put_error_cd(exec, "not a directory"));
if ((i = access(exec, X_OK)) != 0)
put_error_cd(exec, "permission denied");
if (i != 0)
return (NULL);
return (put_error_cd(exec, "permission denied"));
return (exec);
}
return (NULL);
}
int cmd_cd_update_env(char *path, t_list **env, char opt)
int cmd_cd_update_env(char *path, t_env **env, char opt)
{
t_envelem *pwd;
char *oldpwd;
char *c_path;
char p_path[4096];
t_env *pwd;
char *oldpwd;
char *c_path;
char p_path[4096];
ft_bzero(p_path, 4096);
if (getcwd(p_path, 4096) == NULL)
if (!(pwd = ft_envgetelem("PWD", *env)))
return (put_error_cd2(path, "env var PWD undefined"));
if (getcwd(p_path, 4096) == NULL || (oldpwd = ft_strdup(pwd->val)) == NULL
|| ft_realpath(path, &c_path) == NULL)
return (put_error_cd2(path, "error"));
if (ft_envupdate("PWD", *env, ((opt == 'P') ? p_path : c_path)) == NULL
|| ft_envupdate("OLDPWD", *env, oldpwd) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if ((pwd = env_getelemfromkey("PWD", *env)) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if ((oldpwd = ft_strdup(pwd->val)) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if (ft_realpath(path, &c_path) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if (env_addupdate("PWD", ((opt == 'P') ? p_path : c_path), env) == NULL
|| env_addupdate("OLDPWD", oldpwd, env) == NULL)
{
put_error_cd(path, "error");
ft_strdel(&oldpwd);
ft_strdel(&c_path);
return (1);
return (put_error_cd2(path, "error"));
}
ft_strdel(&oldpwd);
ft_strdel(&c_path);
return (0);
}
int cmd_cd_core(char *path, t_list **env, char opt)
int cmd_cd_core(char *path, t_env **env, char opt)
{
t_envelem *pwd;
t_env *pwd;
if (check_path_slash_cd(path) == NULL)
{
put_error_cd(path, "invalid path");
return (1);
}
if (chdir(path) == -1
|| (pwd = env_getelemfromkey("PWD", *env)) == NULL)
|| (pwd = ft_envgetelem("PWD", *env)) == NULL)
{
put_error_cd(path, "error");
return (1);
@@ -133,35 +100,42 @@ char cd_getparams(char **argv, size_t *i)
return (ret[0]);
}
int cmd_cd(char **argv, t_list **env)
int cmd_cd_switchboard(char **av, t_env **env, char opt, int i)
{
t_envelem *elem;
size_t i;
char *path;
char opt;
int ret;
t_env *e;
char *p;
int ret;
i = 0;
if ((opt = cd_getparams(argv, &i)) == '\0')
return (1);
if (!argv[i] && (elem = env_getelemfromkey("HOME", *env)) != NULL && elem->val != NULL)
return (cmd_cd_core(elem->val, env, opt));
else if (argv[i] && argv[i][0] == '/')
return (cmd_cd_core(argv[i], env, opt));
else if (argv[i] && argv[i][0] == '-' && (elem = env_getelemfromkey("OLDPWD", *env)) != NULL)
return (cmd_cd_core(elem->val, env, opt));
else if (argv[i] && argv[i][0] != '/' && (elem = env_getelemfromkey("PWD", *env)) != NULL && elem->val != NULL)
if ((!av[i] && (e = ft_envgetelem("HOME", *env)) != NULL && e->val
!= NULL) || (av[i] && av[i][0] == '-'
&& (e = ft_envgetelem("OLDPWD", *env)) != NULL))
return (cmd_cd_core(e->val, env, opt));
else if (av[i] && av[i][0] == '/')
return (cmd_cd_core(av[i], env, opt));
else if (av[i] && av[i][0] != '/'
&& (e = ft_envgetelem("PWD", *env)) != NULL && e->val != NULL)
{
if ((path = ft_strnew(ft_strlen(elem->val) + ft_strlen(argv[i]) + 1)) == NULL)
put_error_cd(argv[i], "memory error");
if (path == NULL)
if ((p = ft_strnew(ft_strlen(e->val) + ft_strlen(av[i]) + 1)) == NULL)
put_error_cd(av[i], "memory error");
if (p == NULL)
return (1);
ft_strcpy(path, elem->val);
path[ft_strlen(path)] = '/';
ft_strcat(path, argv[i]);
ret = cmd_cd_core(path, env, opt);
ft_strdel(&path);
ft_strcpy(p, e->val);
p[ft_strlen(p)] = '/';
ft_strcat(p, av[i]);
ret = cmd_cd_core(p, env, opt);
ft_strdel(&p);
return (ret);
}
return (1);
}
int cmd_cd(char **argv, t_env **env)
{
size_t i;
char opt;
i = 0;
if ((opt = cd_getparams(argv, &i)) == '\0')
return (1);
return (cmd_cd_switchboard(argv, env, opt, i));
}

17
srcs/cmd_echo.c
View File

@@ -5,24 +5,21 @@
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/27 16:14:07 by tmaze #+# #+# */
/* Updated: 2019/01/13 16:58:14 by tmaze ### ########.fr */
/* Created: 2019/09/20 14:42:30 by tmaze #+# #+# */
/* Updated: 2019/11/02 23:04:23 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int cmd_echo(char **argv, t_list **env)
int cmd_echo(char **argv, t_env **env)
{
size_t i;
int i;
(void)env;
i = 0;
while (argv[0] && argv[++i])
{
ft_putstr(argv[i]);
ft_putchar(' ');
}
i = 1;
while (argv[i])
ft_printf("%s ", argv[i++]);
ft_putchar('\n');
return (0);
}

167
srcs/cmd_env.c
View File

@@ -5,144 +5,91 @@
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/12/14 15:54:45 by tmaze #+# #+# */
/* Updated: 2019/02/01 16:26:42 by tmaze ### ########.fr */
/* Created: 2019/09/20 14:33:48 by tmaze #+# #+# */
/* Updated: 2020/01/30 15:41:08 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
void put_error(char *exec, char *file, char *msg)
static void put_env(t_env *env)
{
ft_putstr(exec);
ft_putstr(": ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
}
t_env *it;
void put_env(t_list *env)
{
t_list *tmp;
tmp = env;
while (tmp)
it = env;
while (it)
{
ft_putstr(((t_envelem*)(tmp->content))->key);
ft_putchar('=');
ft_putendl(((t_envelem*)(tmp->content))->val);
tmp = tmp->next;
ft_printf("%s=", it->key);
if (it->val)
ft_printf("%s", it->val);
ft_putchar('\n');
it = it->next;
}
}
t_envelem *envelemdup(t_envelem *elem)
t_env *envcpy(t_env *env)
{
t_envelem *ret;
t_env *cpy;
if ((ret = (t_envelem*)ft_memalloc(sizeof(t_envelem))) == NULL)
return (NULL);
if ((ret->key = ft_strdup(elem->key)) == NULL)
ft_envelemdel(&ret);
if (ret == NULL)
return (0);
if ((ret->val = ft_strdup(elem->val)) == NULL)
{
ft_strdel(&(ret->key));
ft_envelemdel(&ret);
return (NULL);
}
return (ret);
cpy = NULL;
if (env != NULL && (cpy = (t_env*)ft_memalloc(sizeof(t_env))) != NULL)
if ((cpy->key = ft_strdup(env->key)) == NULL
|| (cpy->val = ft_strdup(env->val)) == NULL)
ft_envdelelem(&cpy);
return (cpy);
}
t_list *env_cpy(t_list *env)
int env_cleanup(t_env *env_cp, int code)
{
t_list *ret;
t_list *ind;
t_list *tmp;
t_envelem *envelem;
ft_envdel(&env_cp);
if (code == 2)
ft_putstr_fd("minishell: env: Env copy error\n", 2);
return (code);
}
ret = NULL;
ind = env;
while (ind)
t_env *inline_env(char **argv, int *i, t_env **env_cp)
{
t_env *new;
while (ft_strchr(argv[*i], '='))
{
if ((envelem = envelemdup((t_envelem*)(ind->content))) == NULL)
ft_lstdel(&ret, &ft_lstdelenvelem);
if (envelem == NULL)
break ;
if ((tmp = ft_lstnew((void*)envelem, sizeof(t_envelem))) == NULL
|| ft_lstaddend(&ret, tmp) == NULL)
if ((new = ft_envnew(argv[*i])) == NULL)
{
ft_envelemdel(&envelem);
ft_lstdel(&ret, &ft_lstdelenvelem);
ft_printf("env: memory error\n");
ft_envdel(env_cp);
break ;
}
ft_envelemdel(&envelem);
ind = ind->next;
ft_envaddend(env_cp, new);
(*i)++;
}
return (ret);
return (*env_cp);
}
int exec_env(char **argv, t_list **env)
int cmd_env(char **argv, t_env **env)
{
int ret;
char **env_tab;
char *path;
int i;
t_env *it;
t_env *new;
t_env *env_cp;
if ((env_tab = envlsttotab(*env)) == NULL)
return (1);
if ((path = check_path(argv[0], *env)) == NULL)
ft_del_words_tables(&env_tab);
if (path == NULL)
return (1);
if ((ret = fork()) == 0)
i = 1;
if (!(env_cp = NULL) && !ft_strequ(argv[i], "-i") && (env != NULL))
{
execve(path, argv, env_tab);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
ft_del_words_tables(&env_tab);
exit(1);
}
else if (ret == -1)
return (1);
waitpid(ret, NULL, 0);
ft_del_words_tables(&env_tab);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
return (0);
}
int cmd_env(char **argv, t_list **env)
{
t_envelem *elem;
t_list *env_cp;
t_list *new;
char *tmp;
size_t i;
if (argv[1] == NULL)
put_env(*env);
i = 0;
if ((env_cp = env_cpy(*env)) == NULL)
return (2);
while (argv[++i] && (tmp = ft_strchr(argv[i], '=')))
{
if ((elem = ft_envtoenvelem(argv[i])) == NULL)
ft_lstdel(&env_cp, &ft_lstdelenvelem);
if (elem == NULL)
return (1);
if ((new = ft_lstnew((void*)elem, sizeof(t_envelem))) == NULL)
it = *env;
while (it)
{
ft_envelemdel(&elem);
ft_lstdel(&env_cp, &ft_lstdelenvelem);
return (1);
}
ft_memdel((void**)&elem);
if (ft_lstaddend(&env_cp, new) == NULL)
{
ft_lstdel(&env_cp, &ft_lstdelenvelem);
return (1);
if ((new = envcpy(it)) == NULL)
return (env_cleanup(env_cp, 2));
ft_envaddend(&env_cp, new);
it = it->next;
}
}
ft_lstdel(&env_cp, &ft_lstdelenvelem);
return (0);
else if (ft_strequ(argv[i], "-i"))
i++;
inline_env(argv, &i, &env_cp);
if (argv[i])
exec_cmd(argv + i, &env_cp);
else
put_env(env_cp);
return (env_cleanup(env_cp, 0));
}

33
srcs/cmd_setenv.c
View File

@@ -5,18 +5,35 @@
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/13 16:20:20 by tmaze #+# #+# */
/* Updated: 2019/01/13 17:05:05 by tmaze ### ########.fr */
/* Created: 2019/09/20 14:41:08 by tmaze #+# #+# */
/* Updated: 2019/11/10 21:38:30 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int cmd_setenv(char **argv, t_list **env)
int cmd_setenv(char **argv, t_env **env)
{
if (argv[1] == NULL)
return (-1);
if (env_addupdate(argv[1], argv[2], env) == NULL)
return (-1);
return (0);
t_env *new;
t_env *tmp;
if (argv[1] && (new = ft_envnew(argv[1])) != NULL)
{
if (argv[1] && (tmp = ft_envgetelem(new->key, *env)) != NULL)
{
ft_strdel(&(tmp->val));
tmp->val = new->val;
ft_strdel(&(new->key));
ft_memdel((void**)&new);
}
else
ft_envaddend(env, new);
ft_envclean(env);
return (0);
}
else if (argv[1] && argv[1][0] != '=' && !ft_strchr(argv[1], '='))
ft_printf("minishell: setenv: memory error\n");
else
ft_printf("usage: setenv [KEY]=[value]\n");
return (1);
}

32
srcs/cmd_unsetenv.c
View File

@@ -5,17 +5,35 @@
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/15 14:58:05 by tmaze #+# #+# */
/* Updated: 2019/01/15 15:04:05 by tmaze ### ########.fr */
/* Created: 2019/09/20 14:42:01 by tmaze #+# #+# */
/* Updated: 2019/11/10 15:52:09 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int cmd_unsetenv(char **argv, t_list **env)
int cmd_unsetenv(char **argv, t_env **env)
{
if (argv[1] == NULL)
return (-1);
env_delelem(argv[1], env);
return (0);
t_env **it;
t_env *tmp;
it = env;
if (!argv[1])
{
ft_printf("usage: unsetenv [KEY]\n");
return (1);
}
while (*it)
{
if (ft_strequ((*it)->key, argv[1]))
{
tmp = *it;
*it = tmp->next;
ft_envdelelem(&tmp);
return (0);
}
it = &((*it)->next);
}
ft_printf("Entry %s not found\n", argv[1]);
return (1);
}

222
srcs/exec.c
View File

@@ -1,222 +0,0 @@
'/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* exec.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/27 15:32:29 by tmaze #+# #+# */
/* Updated: 2019/02/01 16:49:31 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
#define S_BIN 5
char **envlsttotab(t_list *env)
{
size_t i;
size_t env_size;
t_list *tmp;
char **ret;
i = 0;
tmp = env;
env_size = ft_lstsize(env);
if ((ret = (char**)ft_memalloc(sizeof(char*) * (env_size + 1))) == NULL)
return (NULL);
while (i <= env_size)
ret[i++] = NULL;
i = 0;
while (tmp)
{
if ((ret[i] = ft_strnew(ft_strlen(((t_envelem*)(tmp->content))->key)
+ ft_strlen(((t_envelem*)(tmp->content))->val) + 1)) == NULL)
{
ft_del_words_tables(&ret);
return (NULL);
}
i++;
tmp = tmp->next;
}
return (ret);
}
/*
** , {"setenv", &cmd_senv}, {"unsetenv", &cmd_senv}, {"env", &cmd_env}};
*/
int ft_isin(char *str, char c)
{
int i;
i = 0;
while (str[i])
if (str[i++] == c)
return (i - 1);
return (-1);
}
void put_error(char *file, char *msg)
{
ft_putstr("minishell: ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
}
char *check_path_slash(char *exec)
{
int i;
struct stat info;
if (ft_isin(exec, '/') != -1 && ft_isin(exec, '.') == -1)
{
if ((i = access(exec, F_OK)) != 0)
put_error(exec, "no such file or directory");
if (i != 0)
return (NULL);
if ((i = stat(exec, &info)) != 0)
put_error(exec, "can't determine info");
if (i != 0)
return (NULL);
if (!S_ISREG(info.st_mode))
{
put_error(exec, "not an executable file");
return (NULL);
}
if ((i = access(exec, X_OK)) != 0)
put_error(exec, "permission denied");
if (i != 0)
return (NULL);
return (exec);
}
return (NULL);
}
char *check_path_dot(char *exec, t_list *env)
{
t_envelem *path;
char *tmp;
char *ret;
if (exec[0] == '.')
{
if ((path = env_getelemfromkey("PWD", env)) == NULL
|| path->val == NULL)
{
put_error(exec, "memory error");
return (NULL);
}
if ((tmp = ft_strjoin(path->val, "/")) == NULL)
put_error(exec, "memory error");
if (tmp == NULL)
return (NULL);
if ((ret = ft_strjoin(tmp, exec)) == NULL)
{
put_error(exec, "memory error");
ft_strdel(&tmp);
return (NULL);
}
ft_strdel(&tmp);
if (access(ret, F_OK) == 0)
{
if (access(ret, X_OK) == 0)
return (ret);
put_error(exec, "permission denied");
ft_strdel(&ret);
return (NULL);
}
put_error(exec, "no such file or directory");
ft_strdel(&ret);
}
return (NULL);
}
char *check_path(char *exec, t_list *env)
{
size_t i;
t_envelem *path;
char **path_elems;
char *tmp;
char *ret;
i = 0;
ret = NULL;
if ((ret = check_path_slash(exec)) != NULL)
return (ret);
if ((ret = check_path_dot(exec, env)) != NULL)
return (ret);
if ((path = env_getelemfromkey("PATH", env)) == NULL
|| path->val == NULL)
return (NULL);
if ((path_elems = ft_strsplit(path->val, ':')) == NULL)
return (NULL);
while (path_elems[i])
{
if ((tmp = ft_strjoin(path_elems[i], "/")) == NULL)
put_error(exec, "memory error");
if (tmp == NULL)
break ;
if ((ret = ft_strjoin(tmp, exec)) == NULL)
{
put_error(exec, "memory error");
ft_strdel(&tmp);
break ;
}
ft_strdel(&tmp);
if (access(ret, F_OK) == 0)
{
if (access(ret, X_OK) == 0)
break ;
put_error(exec, "permission denied");
}
ft_strdel(&ret);
i++;
}
if (path_elems[i] == NULL)
put_error(exec, "command not found");
ft_del_words_tables(&path_elems);
return (ret);
}
int exec_cmd(char **argv, t_list **env)
{
int ret;
char **env_tab;
char *path;
size_t i;
static t_builtin builtins[S_BIN] = {{"echo", &cmd_echo},
{"cd", &cmd_cd}, {"setenv", &cmd_setenv},
{"env", &cmd_env}, {"unsetenv", &cmd_unsetenv}};
i = 0;
while (i < S_BIN)
if (ft_strcmp(argv[0], builtins[i++].cmd) == 0)
return ((*(builtins[i - 1].f))(argv, env));
if ((env_tab = envlsttotab(*env)) == NULL)
return (-1);
if ((path = check_path(argv[0], *env)) == NULL)
ft_del_words_tables(&env_tab);
if (path == NULL)
return (-1);
if ((ret = fork()) == 0)
{
execve(path, argv, env_tab);
ft_putendl_fd("minishell: error", 1);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
ft_del_words_tables(&env_tab);
exit(-1);
}
else if (ret == -1)
ft_putendl_fd("minishell: error", 1);
if (ret == -1)
return (-1);
waitpid(ret, NULL, 0);
ft_del_words_tables(&env_tab);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
return (0);
}

203
srcs/main.c
View File

@@ -5,103 +5,130 @@
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/18 13:09:55 by tmaze #+# #+# */
/* Updated: 2019/02/01 10:18:41 by tmaze ### ########.fr */
/* Created: 2019/09/19 17:08:46 by tmaze #+# #+# */
/* Updated: 2020/01/30 13:47:35 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int main(void)
t_env *def_env(void)
{
int ret;
char *cmd;
char **tab_cmd;
t_list *lst_env;
extern char **environ;
t_env *ret;
t_env *n;
char p[PATH_MAX];
if ((lst_env = ft_envtolst(environ)) == NULL)
ft_putendl("Error envtolst");
if (lst_env == NULL)
return (2);
while (1)
n = ft_memalloc(sizeof(t_env));
if (n != NULL && ((n->key = ft_strnew(3)) == NULL || !getcwd(p, PATH_MAX)))
ft_envdelelem(&n);
if (n != NULL)
ft_strcpy(n->key, "PWD");
if (n != NULL && (n->val = ft_strdup(p)) == NULL)
ft_envdelelem(&n);
if (n != NULL)
ft_envaddend(&ret, n);
n = ft_memalloc(sizeof(t_env));
if (n != NULL && (n->key = ft_strnew(5)) == NULL)
ft_envdelelem(&n);
if (n != NULL)
ft_strcpy(n->key, "SHLVL");
if (n != NULL && (n->val = ft_strdup("1")) == NULL)
ft_envdelelem(&n);
if (n != NULL)
ft_envaddend(&ret, n);
return (ret);
}
char *inc_shlvl(char **shlvl)
{
char *ret;
if ((ret = ft_itoa(ft_atoi(*shlvl) + 1)) != NULL)
{
ret = 0;
ft_putstr(FT_COLOR_GREEN);
ft_putstr("$> ");
ft_putstr(FT_RESET);
ret = get_next_line(1, &cmd);
if (cmd != NULL && ft_strlen(cmd) != 0)
{
if (ret == -1)
{
ft_lstdel(&lst_env, &ft_lstdelenvelem);
ft_strdel(&cmd);
return (2);
}
if (ft_strcmp("exit", cmd) == 0)
{
ft_lstdel(&lst_env, &ft_lstdelenvelem);
ft_strdel(&cmd);
return (0);
}
else if ((tab_cmd = ft_strsplit(cmd, ' ')) == NULL)
{
ft_lstdel(&lst_env, &ft_lstdelenvelem);
ft_strdel(&cmd);
ft_putendl("error split");
return (2);
}
ft_strdel(&cmd);
ft_putnbr(exec_cmd(tab_cmd, &lst_env));
ft_putchar('\n');
ft_del_words_tables(&tab_cmd);
}
ft_strdel(&cmd);
ft_strdel(shlvl);
*shlvl = ret;
}
ft_lstdel(&lst_env, &ft_lstdelenvelem);
return (ret);
}
t_env *env2lst(char **env)
{
t_env *ret;
t_env *new;
int i;
i = 0;
ret = NULL;
while (env[i])
{
if ((new = ft_envnew(env[i])) != NULL)
{
if (ft_strequ(new->key, "SHLVL") && ft_str_is_numeric(new->val))
inc_shlvl(&new->val);
ft_envaddend(&ret, new);
}
else
{
ft_envdelelem(&new);
ft_envdel(&ret);
return (NULL);
}
i++;
}
if (i == 0 && ret == NULL && (ret = def_env()) == NULL)
ft_printf("Env: Memory Error\n");
return (ret);
}
void check_exec(char **argv, t_env *env)
{
int i;
static t_builtin built[S_BIN] = {{"env", &cmd_env}, {"cd", &cmd_cd}
, {"setenv", &cmd_setenv}, {"echo", &cmd_echo}
, {"unsetenv", &cmd_unsetenv}};
i = -1;
while (++i < S_BIN)
if (ft_strequ(argv[0], built[i].cmd))
{
built[i].f(argv, &env);
break ;
}
if (i == S_BIN)
exec_cmd(argv, &env);
}
int cleanup(char **argv, t_env *env)
{
ft_del_words_tables(&argv);
ft_envdel(&env);
return (0);
}
/*
** char *cmd;
** char **tab_cmd;
** t_list *lst_env;
** int ret;
** extern char **environ;
**
** if ((lst_env = ft_envtolst(environ)) == NULL)
** ft_putendl("Error envtolst");
** if (lst_env == NULL)
** return (2);
** while (1)
** {
** ret = 0;
** ft_putstr(FT_COLOR_GREEN);
** ft_putstr("$> ");
** ft_putstr(FT_RESET);
** ret = get_next_line(1, &cmd);
** if (ret == -1)
** {
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** ft_strdel(&cmd);
** return (2);
** }
** if (ft_strcmp("exit", cmd) == 0)
** {
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** ft_strdel(&cmd);
** return (0);
** }
** else if ((tab_cmd = ft_strsplit(cmd, ' ')) == NULL)
** {
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** ft_strdel(&cmd);
** ft_putendl("error split");
** return (2);
** }
** exec_cmd(tab_cmd, lst_env);
** }
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** return (0);
*/
int main(void)
{
extern char **environ;
char **argv;
t_env *env;
char *cmd;
if ((env = env2lst(environ)) == NULL)
return (2);
while (1)
{
ft_printf("%s$>%s ", FT_COLOR_GREEN, FT_RESET);
if (ft_getline(&cmd) >= 0 && cmd != NULL
&& (argv = ft_strsplit(cmd, ' ')) != NULL && !ft_strdel_null(&cmd))
{
if ((res_ext(argv, env)) != NULL)
{
if (ft_strequ(argv[0], "exit"))
return (cleanup(argv, env));
check_exec(argv, env);
}
}
ft_strdel(&cmd);
ft_del_words_tables(&argv);
}
return (0);
}

99
srcs/ms_env.c
View File

@@ -1,99 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ms_env.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/13 14:44:20 by tmaze #+# #+# */
/* Updated: 2019/01/25 16:05:29 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_envelem *elem_new(char *key, char *val)
{
t_envelem *elem;
if ((elem = (t_envelem*)ft_memalloc(sizeof(t_envelem))) == NULL)
return (NULL);
if ((elem->key = ft_strdup(key)) == NULL)
{
ft_memdel((void**)&elem);
return (NULL);
}
if (val != NULL && (elem->val = ft_strdup(val)) == NULL)
{
ft_strdel(&(elem->key));
ft_memdel((void**)&elem);
return (NULL);
}
elem->val = (val == NULL) ? NULL : elem->val;
return (elem);
}
t_envelem *env_getelemfromkey(char *key, t_list *env)
{
t_list *tmp;
tmp = env;
while (tmp)
{
if (ft_strcmp(((t_envelem*)(tmp->content))->key, key) == 0)
return ((t_envelem*)(tmp->content));
tmp = tmp->next;
}
return (NULL);
}
t_envelem *env_addupdate(char *key, char *val, t_list **env)
{
t_list *new;
t_envelem *elem;
char *tmp;
if ((elem = env_getelemfromkey(key, *env)) != NULL)
{
if (val == NULL)
tmp = val;
else if ((tmp = ft_strdup(val)) == NULL)
return (NULL);
ft_strdel(&(elem->val));
elem->val = tmp;
return (elem);
}
if ((elem = elem_new(key, val)) == NULL
|| (new = ft_lstnew(elem, sizeof(t_envelem))) == NULL)
return (NULL);
ft_lstaddend(env, new);
ft_memdel((void**)&elem);
return ((t_envelem*)(new->content));
}
void env_delelem(char *key, t_list **env)
{
t_list *tmp;
t_list *prec;
if (ft_strcmp(((t_envelem*)((*env)->content))->key, key) == 0)
{
tmp = *env;
*env = (*env)->next;
ft_lstdelone(&tmp, &ft_lstdelenvelem);
return ;
}
tmp = (*env)->next;
prec = (*env);
while (tmp)
{
if (ft_strcmp(((t_envelem*)(tmp->content))->key, key) == 0)
{
prec->next = tmp->next;
ft_lstdelone(&tmp, &ft_lstdelenvelem);
return ;
}
prec = tmp;
tmp = tmp->next;
}
}

85
srcs/ms_env2.c
View File

@@ -1,85 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ms_env2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/01 10:18:01 by tmaze #+# #+# */
/* Updated: 2019/02/01 11:16:28 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_envelem *ft_envtoenvelem(char *env)
{
size_t i;
t_envelem *ret;
i = 0;
if ((ret = (t_envelem*)ft_memalloc(sizeof(t_envelem))) == NULL)
return (NULL);
while (env[i] && env[i] != '=')
i++;
if ((ret->key = ft_strnew(i)) == NULL)
{
ft_memdel((void**)&ret);
return (NULL);
}
if ((ret->val = ft_strnew(ft_strlen(env) - i - 1)) == NULL)
{
ft_memdel((void**)&ret);
return (NULL);
}
ft_strlcpy(ret->key, env, i + 1);
ft_strlcpy(ret->val, &env[i + 1], ft_strlen(env) - i);
return (ret);
}
void ft_lstdelenvelem(void *content, size_t size)
{
size = 0;
ft_strdel(&(((t_envelem*)(content))->key));
ft_strdel(&(((t_envelem*)(content))->val));
ft_memdel(&content);
}
void ft_envelemdel(t_envelem **env)
{
ft_strdel(&((*env)->key));
ft_strdel(&((*env)->val));
ft_memdel((void**)env);
}
t_list *ft_envtolst(char **env)
{
size_t i;
t_list *ret;
t_list *new;
t_envelem *elem;
ret = NULL;
i = 0;
while (env[i])
{
if ((elem = ft_envtoenvelem(env[i])) == NULL)
ft_lstdel(&ret, &ft_lstdelenvelem);
if (elem == NULL)
return (NULL);
if ((new = ft_lstnew((void*)elem, sizeof(t_envelem))) == NULL)
{
ft_envelemdel(&elem);
ft_lstdel(&ret, &ft_lstdelenvelem);
return (NULL);
}
ft_envelemdel(&elem);
if (ft_lstaddend(&ret, new) == NULL)
{
ft_lstdel(&ret, &ft_lstdelenvelem);
return (NULL);
}
i++;
}
return (ret);
}

183
srcs/ms_exec.c Normal file
View File

@@ -0,0 +1,183 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ms_exec.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/09/26 16:25:00 by tmaze #+# #+# */
/* Updated: 2020/01/30 11:48:25 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int ft_isin(char *str, char c)
{
int i;
i = 0;
while (str && str[i])
if (str[i++] == c)
return (i - 1);
return (-1);
}
void *put_error(char *file, char *msg)
{
ft_putstr("minishell: ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
return (NULL);
}
char *check_path_slash(char *exec)
{
int i;
struct stat info;
if ((i = access(exec, F_OK)) != 0)
put_error(exec, "no such file or directory");
if (i != 0)
return (NULL);
if ((i = stat(exec, &info)) != 0)
put_error(exec, "can't determine info");
if (i != 0)
return (NULL);
if (!S_ISREG(info.st_mode))
{
put_error(exec, "not an executable file");
return (NULL);
}
if ((i = access(exec, X_OK)) != 0)
put_error(exec, "permission denied");
if (i != 0)
return (NULL);
return (exec);
}
char *check_path_dot(char *exec, t_env *env)
{
t_env *path;
char *tmp;
char *ret;
if ((path = ft_envgetelem("PWD", env)) == NULL
|| path->val == NULL || (tmp = ft_strjoin(path->val, "/")) == NULL)
return (put_error(exec, "memory error"));
if ((ret = ft_strjoin(tmp, exec)) == NULL)
put_error(exec, "memory error");
ft_strdel(&tmp);
if (ret == NULL)
return (NULL);
if (access(ret, F_OK) == 0)
{
if (access(ret, X_OK) == 0)
return (exec);
ft_strdel(&ret);
return (put_error(exec, "permission denied"));
}
ft_strdel(&ret);
return (put_error(exec, "no such file or directory"));
}
void *ft_strdel_null(char **s)
{
ft_strdel(s);
return (NULL);
}
char *check_path_elems(char **path_elems, char *exec)
{
int i;
char *tmp;
char *ret;
i = -1;
ret = NULL;
while (path_elems[++i])
{
if ((tmp = ft_strjoin(path_elems[i], "/")) == NULL
&& !put_error(exec, "memory error"))
break ;
if ((ret = ft_strjoin(tmp, exec)) == NULL
&& !put_error(exec, "memory error") && !ft_strdel_null(&tmp))
break ;
if (!ft_strdel_null(&tmp) && access(ret, F_OK) == 0)
{
if (access(ret, X_OK) == 0)
break ;
ft_strdel(&ret);
ft_del_words_tables(&path_elems);
return (put_error(exec, "permission denied"));
}
ft_strdel(&ret);
}
return (ret);
}
char *check_path(char *exec, t_env *env)
{
size_t i;
t_env *path;
char **path_elems;
char *ret;
ret = NULL;
if (exec)
{
if (ft_isin(exec, '/') != -1 && ft_isin(exec, '.') == -1)
return (check_path_slash(exec));
if (exec[0] == '.')
return (check_path_dot(exec, env));
if ((path = ft_envgetelem("PATH", env)) == NULL
|| path->val == NULL
|| (path_elems = ft_strsplit(path->val, ':')) == NULL)
return (put_error(exec, "could not resolve path"));
i = 0;
if ((ret = check_path_elems(path_elems, exec)) == NULL)
{
ft_del_words_tables(&path_elems);
return (put_error(exec, "command not found"));
}
ft_del_words_tables(&path_elems);
}
return (ret);
}
void exec_cmd_child(char *path, char **argv, char **env_tab, t_env **env)
{
execve(path, argv, env_tab);
ft_putendl_fd("minishell: error", 1);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
ft_del_words_tables(&env_tab);
ft_envdel(env);
exit(-1);
}
int exec_cmd(char **argv, t_env **env)
{
int ret;
char **env_tab;
char *path;
if ((env_tab = ft_envtotab(*env)) == NULL)
return (-1);
if ((path = check_path(argv[0], *env)) == NULL)
ft_del_words_tables(&env_tab);
if (path == NULL)
return (-1);
if ((ret = fork()) == 0)
exec_cmd_child(path, argv, env_tab, env);
else if (ret == -1)
ft_putendl_fd("minishell: error", 1);
if (ret == -1)
return (-1);
waitpid(ret, NULL, 0);
ft_del_words_tables(&env_tab);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
return (0);
}

117
srcs/ms_ext.c Normal file
View File

@@ -0,0 +1,117 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ms_ext.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/10/25 18:21:47 by tmaze #+# #+# */
/* Updated: 2020/01/30 15:42:17 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
void *return_null(char *msg)
{
ft_printf("%s\n", msg);
return (NULL);
}
void ft_strreplace(char **dst, char *src, int *index, t_env *elem)
{
if (*dst != NULL)
ft_strdel(dst);
*dst = src;
*index = ft_strlen(elem->val);
}
t_env *search_key(t_env *env, char *cmd, int index)
{
t_env *it;
t_env *ret;
int i;
int j;
it = env;
ret = NULL;
while (it && cmd[index + 1])
{
i = 0;
j = index;
while (it->key[i] && cmd[j] && it->key[i] == cmd[j])
{
i++;
j++;
}
if (!it->key[i] && (!ret || ft_strlen(it->key) > ft_strlen(ret->key)))
ret = it;
it = it->next;
}
return (ret);
}
char *replace_env(char *src, t_env *elem, int key_size, int i)
{
char *ret;
int res_len;
res_len = ft_strlen(src) - key_size + ft_strlen(elem->val);
ft_printf("size replace: %d\n", res_len);
if ((ret = ft_strnew(res_len)) != NULL)
{
ft_strncpy(ret, src, i);
ft_strlcat(ret, elem->val, res_len + 1);
ft_strlcat(ret, src + key_size, res_len + 1);
}
else
ft_printf("minishell: memory error\n");
return (ret);
}
char *resolve_complete_key(char **src, int *index, t_env *env)
{
t_env *tmp;
char *ret;
if ((tmp = search_key(env, *src, *index + 1)) != NULL)
{
if ((ret = replace_env(*src, tmp, ft_strlen(tmp->key)
+ 1, *index)) != NULL)
{
ft_strreplace(src, ret, index, tmp);
return (*src);
}
else
return (return_null("minishell: memory error"));
}
else
return (return_null("minishell: variable not found"));
}
char **res_ext(char **av, t_env *env)
{
int i[2];
t_env *tmp;
char *ret;
i[0] = -1;
while (av && av[++i[0]] && !(i[1] = 0))
{
while (av[i[0]][i[1]])
{
if (av[i[0]][i[1]] != '$' && av[i[0]][i[1]] != '~')
i[1]++;
else if (av[i[0]][i[1]] == '~' && (tmp = ft_envgetelem("HOME", env))
!= NULL && (ret = replace_env(av[i[0]], tmp, 1, i[1])) != NULL)
ft_strreplace(&av[i[0]], ret, &i[1], tmp);
else if (av[i[0]][i[1]] == '~' && (tmp = ft_envgetelem("HOME", env))
== NULL)
return (return_null("Entry HOME not found\n"));
else if (av[i[0]][i[1]] == '$'
&& resolve_complete_key(&av[i[0]], &i[1], env) == NULL)
return (NULL);
}
}
return (av);
}

31
srcs/put_error_cd.c Normal file
View File

@@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* put_error_cd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/01/26 22:18:09 by tmaze #+# #+# */
/* Updated: 2020/01/26 22:18:24 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
void *put_error_cd(char *file, char *msg)
{
ft_putstr("cd: ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
return (NULL);
}
int put_error_cd2(char *file, char *msg)
{
ft_putstr("cd: ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
return (1);
}