WIP check path to launch executable

- able to launch ls from path
- full user entry check (non existing exec, empty command..) still to do

Makefile

@@ -6,7 +6,7 @@
 #    By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2018/11/22 14:43:33 by tmaze             #+#    #+#              #
-#    Updated: 2019/01/07 18:06:46 by tmaze            ###   ########.fr        #
+#    Updated: 2019/01/15 15:11:04 by tmaze            ###   ########.fr        #
 #                                                                              #
 #******************************************************************************#
 
@@ -16,9 +16,9 @@ CCSTD :=
 
 NAME := minishell
 
-SRCS := main.c exec.c cmd_echo.c cmd_cd.c
+SRCS := main.c exec.c cmd_echo.c cmd_cd.c cmd_env.c cmd_setenv.c cmd_unsetenv.c ms_env.c
 OBJS_DIR := objs
-OBJS := $(addprefix $(OBJS_DIR)/, $(SRCS:.c=.o))
+OBJS := $(SRCS:.c=.o)
 INCLS := -Iincludes -Ilibft
 LIBS := -Llibft -lft
 
@@ -29,7 +29,7 @@ all: $(NAME)
 $(NAME): $(OBJS) libft/libft.a
 	$(CC) $(CCFLAGS) $(CCSTD) $(INCLS) $(OBJS) -o $(NAME) $(LIBS)
 
-$(OBJS_DIR)/%.o: srcs/%.c includes/minishell.h $(OBJS_DIR)
+%.o: srcs/%.c includes/minishell.h
 	$(CC) $(CCFLAGS) $(CCSTD) $(INCLS) -c $< -o $@
 
 $(OBJS_DIR):

includes/minishell.h

@@ -6,7 +6,7 @@
 /*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2018/11/18 13:12:34 by tmaze             #+#    #+#             */
-/*   Updated: 2019/01/08 17:38:25 by tmaze            ###   ########.fr       */
+/*   Updated: 2019/01/15 15:09:58 by tmaze            ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@
 typedef struct	s_builtin
 {
 	char		*cmd;
-	int			(*f)(char **argv, char **envp);
+	int			(*f)(char **argv, t_list **env);
 }				t_builtin;
 
 typedef struct	s_envelem
@@ -29,8 +29,18 @@ typedef struct	s_envelem
 	char		*val;
 }				t_envelem;
 
-int	exec_cmd(char **argv, char **env);
+t_envelem		*elem_new(char *key, char *val);
-int	cmd_echo(char **argv, char **env);
+t_envelem		*env_getelemfromkey(char *key, t_list *env);
-int	cmd_cd(char **argv, char **env);
+t_envelem		*env_addupdate(char *key, char *val, t_list **env);
+void			env_delelem(char *key, t_list **env);
+
+void			ft_lstdelenvelem(void *content, size_t size);
+
+int				exec_cmd(char **argv, t_list **env);
+int				cmd_echo(char **argv, t_list **env);
+int				cmd_cd(char **argv, t_list	**env);
+int				cmd_env(char **argv, t_list **env);
+int				cmd_setenv(char **argv, t_list **env);
+int				cmd_unsetenv(char **argv, t_list **env);
 
 #endif

srcs/cmd_cd.c

@@ -0,0 +1,20 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   cmd_cd.c                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/01/07 16:44:40 by tmaze             #+#    #+#             */
+/*   Updated: 2019/01/16 13:46:47 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "minishell.h"
+
+int	cmd_cd(char **argv, t_list **env)
+{
+	(void)argv;
+	(void)env;
+	return (0);
+}

srcs/cmd_echo.c

@@ -6,13 +6,13 @@
 /*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2018/11/27 16:14:07 by tmaze             #+#    #+#             */
-/*   Updated: 2018/11/27 17:29:35 by tmaze            ###   ########.fr       */
+/*   Updated: 2019/01/13 16:58:14 by tmaze            ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "minishell.h"
 
-int	cmd_echo(char **argv, char **env)
+int	cmd_echo(char **argv, t_list **env)
 {
 	size_t	i;
 

srcs/cmd_env.c

@@ -1,36 +1,30 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   main.c                                             :+:      :+:    :+:   */
+/*   cmd_env.c                                          :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2018/11/23 14:24:53 by tmaze             #+#    #+#             */
+/*   Created: 2018/12/14 15:54:45 by tmaze             #+#    #+#             */
-/*   Updated: 2018/11/26 12:50:19 by tmaze            ###   ########.fr       */
+/*   Updated: 2019/01/13 17:48:51 by tmaze            ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
-#include <unistd.h>
+#include "minishell.h"
-#include <stdio.h>
 
-#include "../libft/libft.h"
+int	cmd_env(char **argv, t_list **env)
-
-static void ft_cntdelstr(void* content, size_t content_size)
 {
-    ft_strdel((char**)content);
+	t_list	*tmp;
-    content_size = 0;
-}
 
-int	main(int argc, char **argv)
+	if (argv[1] != NULL)
-{
+		return (0);
-	extern	char	**environ;
+	tmp = *env;
-	t_list	*lst;
+	while (tmp)
-	int				i;
+	{
-
+		ft_putstr(((t_envelem*)(tmp->content))->key);
-	i = -1;
+		ft_putchar('=');
-	while (environ[++i])
+		ft_putendl(((t_envelem*)(tmp->content))->val);
-		printf("%s\n", environ[i]);
+		tmp = tmp->next;
-	if (argc > 1)
+	}
-		if ((lst = ft_strsplitstr2()))
 	return (0);
 }

srcs/cmd_setenv.c

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   cmd_setenv.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   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       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "minishell.h"
+
+int	cmd_setenv(char **argv, t_list **env)
+{
+	if (argv[1] == NULL)
+		return (-1);
+	if (env_addupdate(argv[1], argv[2], env) == NULL)
+		return (-1);
+	return (0);
+}

srcs/cmd_unsetenv.c

@@ -0,0 +1,21 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   cmd_unsetenv.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   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       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "minishell.h"
+
+int	cmd_unsetenv(char **argv, t_list **env)
+{
+	if (argv[1] == NULL)
+		return (-1);
+	env_delelem(argv[1], env);
+	return (0);
+}

srcs/exec.c

@@ -6,29 +6,120 @@
 /*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2018/11/27 15:32:29 by tmaze             #+#    #+#             */
-/*   Updated: 2019/01/07 18:57:22 by tmaze            ###   ########.fr       */
+/*   Updated: 2019/01/16 17:26:43 by tmaze            ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "minishell.h"
 
-#define S_BIN	2
+#define S_BIN	5
 
-int	exec_cmd(char **argv, char **env)
+char	**envlsttotab(t_list *env)
 {
-	size_t				i;
+	size_t		i;
-	static t_builtin	builtins[S_BIN] = {{"echo", &cmd_echo}, {"cd", &cmd_cd}};
+	size_t		env_size;
-
+	t_list		*tmp;
-	/*, {"setenv", &cmd_senv}, {"unsetenv", &cmd_senv}, {"env", &cmd_env}}; */
+	char		**ret;
 
 	i = 0;
-	while (i < S_BIN)
+	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 (ft_strcmp(argv[0], builtins[i].cmd) == 0)
+		if ((ret[i] = ft_strnew(ft_strlen(((t_envelem*)(tmp->content))->key)
-			return ((*(builtins[i].f))(argv, env));
+				+ 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}};
+*/
+
+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 ((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)
+			break ;
+		if ((ret = ft_strjoin(tmp, exec)) == NULL)
+			ft_strdel(&tmp);
+		if (ret == NULL)
+			break ;
+		ft_strdel(&tmp);
+		if (access(ret, F_OK) == 0 && access(ret, X_OK) == 0)
+			break ;
+		ft_strdel(&ret);
 		i++;
 	}
-	execve(argv[0], argv, env);
+	ft_del_words_tables(&path_elems);
-	ft_putendl("minishell: error");
+	return (ret);
-	return (1);
+}
+
+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;
+	path = NULL;
+	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 (argv[0][0] == '/' && access(argv[0], F_OK) == 0 && access(argv[0], X_OK) == 0)
+		path = argv[0];
+	else if ((path = check_path(argv[0], *env)) == NULL)
+		ft_putendl_fd("minishell: error path check", 2);
+	else
+	{
+		ft_del_words_tables(&env_tab);
+		return (-1);
+	}
+	if ((ret = fork()) == 0)
+	{
+		if (path != NULL)
+			execve(path, argv, env_tab);
+		ft_putendl_fd("minishell: error", 2);
+		ft_strdel(&path);
+		ft_del_words_tables(&env_tab);
+		exit(-1);
+	}
+	else if (ret == -1)
+		ft_putendl_fd("minishell: error", 2);
+	if (ret == -1)
+		return (-1);
+	waitpid(ret, NULL, 0);
+	ft_del_words_tables(&env_tab);
+	return (0);
 }

srcs/main.c

@@ -6,62 +6,12 @@
 /*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2018/11/18 13:09:55 by tmaze             #+#    #+#             */
-/*   Updated: 2019/01/08 18:33:40 by tmaze            ###   ########.fr       */
+/*   Updated: 2019/01/16 17:06:51 by tmaze            ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "minishell.h"
 
-char	**ft_strtabcpy(char **tab)
-{
-	char	**ret;
-	size_t	size_tab;
-
-	size_tab = 0;
-	while (tab[size_tab])
-		size_tab++;
-	if ((ret = (char**)ft_memalloc(sizeof(char*) * size_tab)) == NULL)
-		return (NULL);
-	size_tab = 0;
-	while (tab[size_tab])
-	{
-		if ((ret[size_tab] = ft_strdup(tab[size_tab])) == NULL)
-		{
-			ft_del_words_tables(&ret);
-			break ;
-		}
-		size_tab++;
-	}
-	return (ret);
-}
-
-void	ft_lstdelstr(void *content, size_t content_size)
-{
-	content_size = 0;
-	ft_strdel((void*)&content);
-}
-
-t_list	*ft_strtabtolst(char **tab)
-{
-	t_list	*ret;
-	t_list	*new;
-	size_t	i;
-
-	i = 0;
-	ret = NULL;
-	while (tab[i])
-	{
-		if ((new = ft_lstnew(tab[i], ft_strlen(tab[i]))) == NULL)
-		{
-			ft_lstdel(&ret, &ft_lstdelstr);
-			return (NULL);
-		}
-		ft_lstaddend(&ret, new);
-		i++;
-	}
-	return (ret);
-}
-
 t_envelem	*ft_envtoenvelem(char *env)
 {
 	size_t		i;
@@ -72,48 +22,83 @@ t_envelem	*ft_envtoenvelem(char *env)
 		return (NULL);
 	while (env[i] && env[i] != '=')
 		i++;
-	if ((ret->key = (char*)ft_strnew(i)) = NULL)
+	if ((ret->key = ft_strnew(i)) == NULL)
 	{
 		ft_memdel((void**)&ret);
 		return (NULL);
 	}
-	if ((ret->value = (char*)ft_strnew(ft_strlen(ft_strrlen(env) - i - 1))) = NULL)
+	if ((ret->val = ft_strnew(ft_strlen(env) - i - 1)) == NULL)
 	{
 		ft_memdel((void**)&ret);
 		return (NULL);
 	}
-	ft_strlcpy(ret->key, env, i);
+	ft_strlcpy(ret->key, env, i + 1);
-	ft_strlcpy(ret->key, env + i + 1, ft_strrlen(env) - i - 1);
+	ft_strlcpy(ret->val, &env[i + 1], ft_strlen(env) - i);
-	return (&ret);
+	return (ret);
 }
 
-t_list	*ft_envtolst(char **env)
+void		ft_lstdelenvelem(void *content, size_t size)
 {
-
+	size = 0;
+	ft_strdel(&(((t_envelem*)(content))->key));
+	ft_strdel(&(((t_envelem*)(content))->val));
+	if ((((t_envelem*)(content))->key) != NULL
+		|| (((t_envelem*)(content))->val) != NULL)
+		ft_putstr("plup\n");
+	ft_memdel(&content);
 }
 
-int main(void)
+void		ft_envelemdel(t_envelem **env)
 {
-	char			*cmd;
+	ft_strdel(&((*env)->key));
-	char			**myenv;
+	ft_strdel(&((*env)->val));
-	char			**tab_cmd;
+	ft_memdel((void**)env);
-	t_list			*lst_env;
+}
-	int				ret;
-	extern	char	**environ;
 
-	lst_env = NULL;
+t_list		*ft_envtolst(char **env)
-	if ((myenv = ft_strtabcpy(environ)) == NULL)
+{
+	size_t		i;
+	t_list		*ret;
+	t_list		*new;
+	t_envelem	*elem;
+
+	ret = NULL;
+	i = 0;
+	while (env[i])
 	{
-		ft_putendl("error alloc");
+		if ((elem = ft_envtoenvelem(env[i])) == NULL)
-		return (2);
+			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_memdel((void**)&elem);
+		if (ft_lstaddend(&ret, new) == NULL)
+		{
+			ft_lstdel(&ret, &ft_lstdelenvelem);
+			return (NULL);
+		}
+		i++;
 	}
-	if ((lst_env = ft_strtabtolst(myenv)) == NULL)
+	return (ret);
-	{
+}
-		ft_del_words_tables(&myenv);
+
-		ft_putendl("error alloc 2");
+int			main(void)
+{
+	int			ret;
+	char		*cmd;
+	char		**tab_cmd;
+	t_list		*lst_env;
+	extern char	**environ;
+
+	if ((lst_env = ft_envtolst(environ)) == NULL)
+		ft_putendl("Error envtolst");
+	if (lst_env == NULL)
 		return (2);
-	}
-	ft_del_words_tables(&myenv);
 	while (1)
 	{
 		ret = 0;
@@ -121,34 +106,76 @@ int main(void)
 		ft_putstr("$> ");
 		ft_putstr(FT_RESET);
 		ret = get_next_line(1, &cmd);
-		if (ret == -1)
+		if (cmd != NULL && ft_strlen(cmd) != 0)
 		{
-			ft_lstdel(&lst_env, &ft_lstdelstr);
+			if (ret == -1)
-			ft_strdel(&cmd);
+			{
-			return (2);
+				ft_lstdel(&lst_env, &ft_lstdelenvelem);
-		}
+				ft_strdel(&cmd);
-		if (ft_strcmp("exit", cmd) == 0)
+				return (2);
-		{
+			}
-			ft_lstdel(&lst_env, &ft_lstdelstr);
+			if (ft_strcmp("exit", cmd) == 0)
-			ft_strdel(&cmd);
+			{
-			return (0);
+				ft_lstdel(&lst_env, &ft_lstdelenvelem);
-		}
+				ft_strdel(&cmd);
-		else if ((tab_cmd = ft_strsplit(cmd, ' ')) == NULL)
+				return (0);
-		{
+			}
-			ft_lstdel(&lst_env, &ft_lstdelstr);
+			else if ((tab_cmd = ft_strsplit(cmd, ' ')) == NULL)
-			ft_strdel(&cmd);
+			{
-			ft_putendl("error split");
+				ft_lstdel(&lst_env, &ft_lstdelenvelem);
-			return (2);
+				ft_strdel(&cmd);
-		}
+				ft_putendl("error split");
-		if ((ret = fork()) == 0)
+				return (2);
-			exit(exec_cmd(tab_cmd, myenv));
+			}
-		else
-		{
-			waitpid(ret, NULL, 0);
 			ft_strdel(&cmd);
+			exec_cmd(tab_cmd, &lst_env);
 			ft_del_words_tables(&tab_cmd);
 		}
+		ft_strdel(&cmd);
 	}
-	ft_lstdel(&lst_env, &ft_lstdelstr);
+	ft_lstdel(&lst_env, &ft_lstdelenvelem);
 	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);
+*/

srcs/ms_env.c

@@ -0,0 +1,99 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ms_env.c                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/01/13 14:44:20 by tmaze             #+#    #+#             */
+/*   Updated: 2019/01/13 19:02:04 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;
+	}
+}