int ft_printf(const char *format_string, ...)
{
va_list arguments;
t_format format;
if (!format_string)
{
ft_putendl_fd("ft_printf: format string must be valid", 2);
exit(1);
}
ft_bzero(&format, sizeof(t_format));
format.string = format_string;
va_start(arguments, format_string);
handle_format(&format, arguments);
va_end(arguments);
return (format.written);
}
void ft_regististory(t_linez *l)
{
int fd;
fd = open("hist_cmd", O_CREAT | O_WRONLY | O_TRUNC, 0666);
while (l->prev)
l = l->prev;
while (l && l->line)
{
if (ft_isprint(l->line[0]))
{
replace_char(l->line, '\n', '\0');
ft_putendl_fd(l->line, fd);
}
l = l->next;
}
}
void sh_builtin_exit(char **av)
{
unsigned char val;
val = 0;
if (av && av[1])
{
if (ft_isdigit(av[1][0]))
val = ft_atoi(av[1]);
else
{
ft_putendl_fd("exit: Expression Syntax.", 2);
return ;
}
}
exit(val);
}
void ms_str_lstdel(t_str **l_str, int fd)
{
t_str *current;
t_str *next;
current = *l_str;
while (current)
{
ft_putendl_fd(current->str, fd);
next = current->next;
cool_free(current->str);
cool_free(current);
if (next == NULL)
break ;
current = next;
}
current = NULL;
}
static void pipe_error(char *err, int p, t_env *e)
{
if (err)
{
ft_putstr_fd("21sh: ", 2);
ft_putendl_fd(err, 2);
e->ret = 1;
}
else if (e->ret == 512)
{
ft_putchar('\n');
e->ret = 130;
}
if (p > -1)
close(p);
init_sigint(0);
redefine_term();
}
void check_tab(char **tab)
{
int fd;
while (*tab)
{
if ((fd = open(*tab, O_RDONLY)) != -1)
close(fd);
else
{
ft_putstr_fd("ls: ", 2);
ft_putstr_fd(*tab, 2);
ft_putendl_fd(": No such file or directory 0", 2);
exit(-1);
}
tab++;
}
}
int numeric_error(char **cmd)
{
int i;
i = 0;
while (cmd[1][i])
{
if (cmd[1][i] < '0' || cmd[1][i] > '9')
{
ft_putstr_fd("42sh: history: ", 2);
ft_putstr_fd(cmd[1], 2);
ft_putendl_fd(": numeric argument required", 2);
return (1);
}
i++;
}
return (0);
}
void open_client_message(int cs)
{
char *cs_tostr;
char *str;
char *tmp;
cs_tostr = ft_itoa(cs);
str = ft_strcolor("NEW_CLIENT [", 'n', 'n', 47);
tmp = ft_strcolor(cs_tostr, 'n', 'n', 15);
str = ft_strijoind(str, tmp, 0);
ft_strdel(&tmp);
tmp = ft_strcolor("]", 'n', 'n', 47);
str = ft_strijoind(str, tmp, "\n", 0);
ft_strdel(&tmp);
ft_putstr(str);
ft_putendl_fd(cs_tostr, cs);
ft_stridel(&cs_tostr, &str, 0);
}
int main(int argc, char **argv)
{
if (argc < 1)
{
ft_putendl("And then...?");
return (1);
}
if (tgetent(NULL, getenv("TERM")) == 1)
{
ft_select(argv);
}
else
{
ft_putendl_fd("Error: Terminal not found", 2);
return (1);
}
return (0);
}
static t_bool init_env(t_env **env)
{
int i;
i = -1;
if (init_map(env) == FALSE)
{
ft_putendl_fd("Error: map not created", 2);
return (FALSE);
}
(*env)->pl = ft_memalloc(MAX_PLAYER * sizeof(t_player));
while (++i < MAX_PLAYER)
(*env)->pl[i].used = FALSE;
(*env)->nb = 0;
(*env)->t_nb = 0;
ft_bzero((*env)->t, sizeof((*env)->t));
return (TRUE);
}
int ft_setenv(t_env *e)
{
char *env_var;
if (e->ac == 3)
{
free(e->env[e->ec]);
e->env[e->ec] = malloc(sizeof(char) * 10);
e->env[e->ec + 1] = malloc(sizeof(char) * 1);
e->env[e->ec + 1] = NULL;
env_var = ft_strjoin(e->av[1], "=");
e->env[e->ec] = ft_strjoin(env_var, e->av[2]);
ft_putendl(e->env[e->ec]);
e->ec++;
}
else
ft_putendl_fd("Syntax error, use : setenv var value", 2);
return (2);
}
void exec_env(char **str, int *i, int isnew_env, char **env)
{
pid_t pid;
if ((pid = fork()) < 0)
{
ft_putendl_fd("Fork fail", 2);
return ;
}
if (!pid)
{
if (ft_strchr(*str, '/'))
exec_file(str, isnew_env, env);
else
exec_bin(str, isnew_env, env);
}
else
waitpid(pid, i, 0);
}
void do_unsetenv(t_lst *list, char **cmd)
{
int len;
int i;
i = 0;
len = ft_tablen(cmd);
if (len == 1)
ft_putendl_fd("unsetenv: Too few arguments.", 2);
else if (len > 1)
{
while (cmd[++i])
{
if (ft_strcmp(cmd[i], "="))
cmd[i] = ft_strcat(cmd[i], "=");
list_remove_node(&list, cmd[i]);
}
}
}
int ft_atoi(const char *buf)
{
int nb;
int compt;
nb = 0;
compt = -1;
while (buf[++compt] && buf[compt] != '\n')
{
if (buf[compt] > '9' || buf[compt] < '0')
{
ft_putstr_fd("ft_atoi bad argument:\t", 2);
ft_putendl_fd(buf, 2);
}
else
nb = (nb * 10) + (buf[compt] - '0');
}
return (nb);
}
static int count_indentation(char *line, int line_number)
{
int i;
i = 0;
while (is_space(line[i]))
{
if (line[i] != '\t')
{
ft_putstr_fd("Line ", 2);
ft_putnbr_fd(line_number, 2);
ft_putendl_fd(":\tERROR! Bad Indentation.", 2);
exit(1);
}
else
i++;
}
return (i);
}
static void pipe_left(t_node *tree, int *pipe_fd, t_data *data)
{
char *line;
close(pipe_fd[0]);
get_tmpfd(&data->tmp_pipein, "/.temp_pipein");
read_tree(tree->left);
lseek(data->tmp_pipein, 0, SEEK_SET);
while (get_next_line(data->tmp_pipein, &line) > 0)
{
ft_putendl_fd(line, pipe_fd[1]);
ft_strdel(&line);
}
remove_tmp("/.temp_pipein");
if (g_pid.built == 0 || WEXITSTATUS(g_pid.id) != 0)
exit(EXIT_FAILURE);
else
exit(EXIT_SUCCESS);
}
void ft_see(t_cmd *cmd, t_game *g)
{
t_var var;
char *msg;
char *del;
msg = NULL;
var = init_var(g, cmd);
msg = check_case(g, var, msg, 1);
var.i = 1;
del = msg;
msg = ft_strtrim(msg);
free(del);
msg = ft_strjoin_free("{", msg, 2);
msg = ft_strjoin_free(msg, ",", 1);
ft_while(g, cmd, var, &msg);
msg = ft_strjoin_free(msg, "}", 1);
ft_putendl_fd(msg, cmd->fd);
}
int main(int ac, char **av)
{
t_list *targets;
int flags;
if (ac == 1)
ls_dir(get_newrdir(".", NONE), 0, 0, 0);
else if (checkpute(ac, av))
ft_putendl_fd("ls: fts_open: No such file or directory", 2);
else
{
targets = NULL;
flags = parser(ac, av, &targets);
if (flags >= 0)
pre_parse(targets, flags);
ft_lstdel(&targets, 0);
}
return (0);
}
static int new_map(char *map)
{
char *new_map;
char *buff;
int fd;
buff = ft_strjoin("samples/", map);
new_map = ft_strjoin(buff, ".fdf");
free(buff);
fd = open(new_map, O_RDONLY);
free(new_map);
if (fd <= 0)
fd = open(map, O_RDONLY);
if (fd <= 0)
{
ft_putendl_fd("Error opening the file.", 2);
return (0);
}
return (fd);
}
static int ft_unsetenv(char **cmd, t_mlist *mlist)
{
t_list *tmp;
t_list *cur;
cur = mlist->env;
if (ft_count_tab(cmd) == 1)
return (!ft_putendl_fd("unsetenv: Too few arguments.", 2));
if ((tmp = ft_get_env(cmd[1], mlist->env)) == NULL)
return (1);
while (cur && cur->next && cur->next != tmp)
cur = cur->next;
if (mlist->env && tmp == mlist->env)
mlist->env = mlist->env->next;
else if (cur && tmp)
cur->next = tmp->next;
free(tmp->content);
free(tmp);
return (1);
}
void ft_env(t_env *e, char **b_tab)
{
t_list *env;
env = e->env;
if (ft_tablen(b_tab) != 1)
{
ft_putstr_fd("env: ", 2);
ft_putstr_fd(b_tab[1], 2);
ft_putendl_fd(": No such file or directory", 2);
}
else
{
while (env)
{
ft_putendl(env->content);
env = env->next;
}
}
}
static void build_ip_header(t_env *env, struct iphdr *header)
{
ft_bzero(header, sizeof(*header));
header->version = 4;
header->ihl = 5;
header->tos = 0;
header->tot_len = sizeof(t_packet);
header->id = ICMP_ECHO;
header->frag_off = 0;
header->ttl = 255;
header->protocol = IPPROTO_ICMP;
header->check = 0;
if (inet_pton(AF_INET, env->ip, &header->daddr) != 1)
{
ft_putendl_fd("ft_ping: can't pton ip", 2);
exit(EXIT_FAILURE);
}
header->saddr = 0;
header->check = 0;
}
static char *change_into_number(char *av)
{
char *var_name;
int number;
if (!(var_name = ft_strcdup(av, '=')))
return (av);
if (!(ft_strcmp(var_name, "SHLVL")))
{
if (!(number = ft_atoi(ft_strchr(av, '=') + 1)))
{
free(var_name);
free(av);
ft_putendl_fd("Error : SHLVL must be a number", 2);
return (NULL);
}
}
free(var_name);
return (av);
}
void init_circle(t_scene **scene, t_vec3 center, unsigned int color, float radius)
{
t_circle *circle;
t_scene *new_obj;
circle = (t_circle *)malloc(sizeof(t_circle));
new_obj = (t_scene *)malloc(sizeof(t_scene));
if (circle == NULL || new_obj == NULL)
{
ft_putendl_fd("Fatal error : Failed malloc in init_circle", 2);
exit(-1);
}
init_coord(&circle->center, center.x, center.y, center.z);
circle->r = radius;
new_obj->type = CIRCLE;
new_obj->object = circle;
new_obj->color = color;
new_obj->next = *scene;
*scene = new_obj;
}
void write_pipefile(void)
{
char *line;
t_data *data;
t_fd *tmp;
data = init_data(0);
tmp = data->infildes;
lseek(data->tmp_pipeout, data->offset, SEEK_SET);
while (tmp)
{
while (get_next_line(tmp->fildes, &line) > 0)
{
ft_putendl_fd(line, data->tmp_pipeout);
ft_strdel(&line);
}
tmp = tmp->next;
}
lseek(data->tmp_pipeout, 0, SEEK_SET);
}
int main(void)
{
t_map *map;
map = NULL;
map = ft_lemin_parser(map);
if (map != NULL)
{
ft_display_instructions(map);
ft_multi_pathfinding(map);
if (map->roads->first == NULL)
{
ft_putendl_fd("Error, no path to finish Lem-in", 2);
return (0);
}
ft_init_ants(map);
ft_exec_lemin(map);
}
return (0);
}
int ft_error(char *cmd, char *msg, char *arg)
{
if (cmd != NULL)
ft_putstr_fd(cmd, 2);
else
ft_putstr_fd(FTSH_NAME, 2);
if (msg != NULL)
{
ft_putstr_fd(": ", 2);
ft_putstr_fd(msg, 2);
}
if (arg != NULL)
{
ft_putstr_fd(": ", 2);
ft_putendl_fd(arg, 2);
}
else
ft_putchar_fd('\n', 2);
return (1);
}
int main(int argc, char **argv)
{
t_e e;
if (argc == 1)
return (0);
e.l_a = ft_create_list1(argv, &e, argc);
e.l_b = ft_create_racine();
if (e.l_a == NULL || e.l_b == NULL || (!(ft_check_doublon1(&e))))
{
ft_putendl_fd("Error", 2);
return (-1);
}
if (!(checker_calc(&e)))
return (1);
checker_resolv(&e);
ft_free_list_cir(e.l_a);
ft_free_list_cir(e.l_b);
return (0);
}
static void wait_get(int sock, char *command)
{
char *line;
char *file_name;
int fd;
if (wait_server_pass(sock))
return ;
file_name = get_file_name(command);
if ((fd = open(file_name, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR
| S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) == -1)
return ;
while (get_next_line(sock, &line) > 0 && ft_strcmp(line, "\033"))
{
ft_putendl_fd(line, fd);
free(line);
}
free(file_name);
close(fd);
}
void init_client(int s, t_env *e, t_client client)
{
int father;
t_play player;
father = fork();
if (father > 0)
return ;
if (father == 0)
{
if ((s = client_init(client.port, client.host)) < 0)
{
ft_putendl_fd("Client init error\n", 2);
exit(0);
}
printf("SON\n");
player = init_play(s, client);
ft_loop(s, e, player);
}
}
