int load_tetriminos(t_tetrimino **tetri)
{
DIR *dir;
struct dirent *file;
int fd;
char *fullname;
int counter;
if ((counter = 0) == 0 && (dir = opendir("./tetriminos")) == NULL)
return (my_perror("Error : can not open tetriminos directory\n"));
while ((file = readdir(dir)) != NULL)
if (file->d_name[0] != '.' && is_tetrimino(file->d_name))
{
fullname = get_fullname(file->d_name);
if ((fd = open(fullname, O_RDONLY)) == -1)
return (-1);
free(fullname);
if (get_tetrimino_info(fd, file->d_name, tetri) == -1)
return (-1);
if ((*tetri)->error == 0)
++counter;
close(fd);
}
if (counter == 0)
return (my_perror("No tetrimino detected\n"));
closedir(dir);
return (0);
}
static int use_execve(t_tree *tree, t_env **env, char *cmd)
{
char **tab_env;
char **tab_lex;
int pid;
int exec_val;
exec_val = 0;
if ((tab_env = env_to_tab(*env)) == NULL ||
((tab_lex = lex_to_tab(tree->lexer)) == NULL) ||
((pid = fork()) == -1))
return (my_perror(QUIT_ERR, QUIT_RET));
if (pid == 0)
{
if (execve(cmd, tab_lex, tab_env) == -1)
return (my_perror(QUIT_ERR, QUIT_RET));
}
else
{
if (wait(&exec_val) == -1)
return (my_perror(QUIT_ERR, QUIT_RET));
exec_val = WEXITSTATUS(exec_val);
}
free_tab(tab_env);
free_tab(tab_lex);
free(cmd);
return (exec_val);
}
static char *list_to_send(unsigned int s, char *print)
{
DIR *dir;
struct dirent *tmp;
if ((dir = opendir(".")) == NULL)
{
my_perror(__func__, __LINE__, __FILE__, FAILURE);
return (NULL);
}
while ((tmp = readdir(dir)) != NULL)
{
if ((print = realloc(print, s + strlen(tmp->d_name) + 2)) == NULL)
{
my_perror(__func__, __LINE__ - 2, __FILE__, FAILURE);
return (NULL);
}
strcpy(print + s, tmp->d_name);
tricky(print, &s);
}
if (closedir(dir) == -1)
{
my_perror(__func__, __LINE__ - 2, __FILE__, FAILURE);
return (NULL);
}
return (print);
}
char mysh_quit(t_arg *targ, UNUSED char *str)
{
int nb;
int i;
i = 0;
if ((targ->wtab[1] && ((targ->wtab[1][0] != '-' &&
targ->wtab[1][0] <= '0') || targ->wtab[1][0] >= '9'))
|| targ->wtab[2])
return (my_perror(ERR_SYNT));
while (targ->wtab[1] && targ->wtab[1][++i])
if (targ->wtab[1][i] >= '9' || targ->wtab[1][i] <= '0')
return (my_perror(ERR_SYNT));
targ->ex = 1;
nb = (targ->wtab[1] != NULL) ? my_getnbr(targ->wtab[1]) : 0;
if (targ->env != NULL)
free_tab(targ->env);
if (targ->wtab != NULL)
free_tab(targ->wtab);
if (targ->ptab != NULL)
free_tab(targ->ptab);
if (targ->pwd != NULL)
free(targ->pwd);
targ->env = NULL;
write(1, "exit\n", 5);
return (nb);
}
int complete_put(int fd, FILE *fp, FILE *f, struct stat stat)
{
int i;
size_t len;
char *buff;
len = 0;
buff = my_get_str(stat.st_size);
if (fputstr(fd, buff) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if (fputstr(fd, "\n") == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
buff = my_free(buff);
putstr("0%");
i = process_put(fd, fp, f, stat);
putstr("\r100%%\n");
if (i >= 0)
return (i);
if (fclose(f) == -1)
return (my_perror(EPTYPE, SUCCESS, fd, 0));
while ((i = getline(&buff, &len, fp)) >= 0 && buff[i - 2] != '\r')
putstr(buff);
if (i == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
putcolor(buff);
my_free(buff);
return (SUCCESS);
}
int init_put(int fd, FILE *fp, char **buf, char **tmp)
{
int i;
size_t len;
char *buff;
i = 0;
len = 0;
if (!((*tmp) = strdup(*buf)))
return (my_perror(EALLOC, FAILURE, fd, 0));
buff = (*buf) + 4;
while (buff[0] == ' ' || buff[0] == '\t')
buff += 1;
while (buff[i] && buff[i] != '\n' && buff[i] != ' ' && buff[i] != '\t')
i += 1;
if (buff[i] != '\n')
{
*tmp = my_free(*tmp);
fputstr(fd, "\n");
if (getline(tmp, &len, fp) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
free(*tmp);
return (my_perror(ESYNTAX, SUCCESS, 0, 0));
}
buff[i] = '\0';
(*buf) = buff;
return (-1);
}
int my_put(int fd, FILE *fp, char *buff, size_t len)
{
struct stat stat;
FILE *f;
char *tmp;
char *cpy;
int ret;
cpy = buff;
if ((ret = init_put(fd, fp, &buff, &tmp)) >= 0)
return (ret);
if (access(buff, F_OK) || lstat(buff, &stat) == -1 ||
stat.st_size == 4096 || !(f = fopen(buff, "r")))
{
tmp = my_free(tmp);
if (fputstr(fd, "\n") == -1 || getline(&tmp, &len, fp) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
free(tmp);
if (stat.st_size == 4096)
return (my_perror(EARGNOTIMP, SUCCESS, 0, 0));
return (my_perror(ENOTTAKEN, SUCCESS, 0, 0));
}
free(cpy);
putstr(FSTATOK);
if (rfputstr(fd, tmp) == -1 || (tmp = my_free(tmp)))
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
return (complete_put(fd, fp, f, stat));
}
int process_put(int fd, FILE *fp, FILE *f, struct stat stat)
{
char *buff;
size_t len;
int s;
int i;
s = 0;
len = 0;
buff = 0;
while ((i = getline(&buff, &len, f)) >= 0)
{
s += i;
disp_percentage(100 * s / stat.st_size);
if (write(fd, buff, i) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if (buff[i - 1] != '\n')
if (fputstr(fd, "\n") == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if ((i = getline(&buff, &len, fp)) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if (i >= 2 && buff[i - 2] == '\r' &&
putstr(remove_ret(buff)) && !my_free(buff))
return (SUCCESS);
}
my_free(buff);
return (-1);
}
int my_putstr_termcap(int flag, char *capaity)
{
static int fd = -1;
int indice;
if (flag == CLOSE_FD_TTY)
{
if (close(fd) == -1)
my_perror("close");
return (-1);
}
if (flag != -1)
fd = flag;
if (flag == -1 && fd == -1)
if ((fd = open("/dev/tty", O_RDWR)) == -1)
my_perror("open");
if (fd != -1 && capaity != NULL)
{
indice = -1;
while (capaity[++indice] != '\0');
if (write(fd, capaity, indice) == -1)
my_perror("write");
}
return (fd);
}
double my_getnbrdou(char *s)
{
double nb;
int i;
int j;
i = 0;
nb = 0;
j = 10;
if (s[i] == '-')
i = i + 1;
if (verify_str(s) == -1)
{
my_perror(s);
return (my_perror(W_NUM));
}
while (s[i] != '\0' && (s[i] >= '0' && s[i] <= '9'))
{
nb = nb * 10 + s[i] - '0';
i = i + 1;
}
if (s[i] != '.')
return (nb);
while (s[++i] != '\0')
{
nb = nb + (double)(s[i] - '0') / j;
j = j * 10;
}
return (s[0] == '-' ? -nb : nb);
}
int load_faces(t_triangle *tri, char **tab)
{
t_face *tmp;
unsigned int i;
i = 0;
if ((tmp = bunny_malloc(sizeof(t_face) * (tri->nb_face + 1))) == NULL)
return (my_perror(MALLOC_F));
while (i != tri->nb_face)
{
tmp[i] = tri->face[i];
i = i + 1;
}
if (((tmp[i].f = my_getnbr(tab[1])) == 0) ||
((tmp[i].s = my_getnbr(tab[2])) == 0) ||
((tmp[i].t = my_getnbr(tab[3])) == 0))
return (-1);
if (tmp[i].f > tri->nb_vertices ||
tmp[i].s > tri->nb_vertices ||
tmp[i].t > tri->nb_vertices)
return (my_perror(W_VERTC));
tri->face = tmp;
tri->nb_face += 1;
if (my_tablen(tab) == 5)
if (load_second_face(tri, tab) == -1)
return (-1);
return (0);
}
int handle_clients(int fd, char **pwds)
{
pid_t pid;
int fd_client;
pid = 1;
if (pwds && !get_conf(pwds[ROOT], 0))
return (my_perror(EALLOC, FAILURE, 0, fd));
while (pid != CHILD)
{
if ((fd_client = accept(fd, NULL, NULL)) == -1)
return (my_perror(EACCEPT, EXIT_FAILURE, fd, 0));
if ((pid = fork()) == -1)
return (my_perror(EFORK, FAILURE, fd, fd_client));
if (pid == CHILD)
{
if (close(fd) == -1)
return (my_perror(ESCLOSE, FAILURE, 0, fd_client));
if (!handle_client(fd_client, pwds))
return (FAILURE);
}
else
if (close(fd_client) == -1)
return (my_perror(ECCLOSE, FAILURE, fd, 0));
}
return (SUCCESS);
}
int handle_client(int fd, char **pwds)
{
char *buff;
size_t len;
char *cmd;
FILE *fp;
len = 0;
if (!(fp = fdopen(fd, "r+")))
return (my_perror(EOPEN, FAILURE, 0, fd));
fputstr(fd, "220 Service ready for new user.\r\n");
if (!(buff = my_user(fd, fp, "Anonymous\n", pwds)))
return (FAILURE);
buff = my_free(buff);
while (getline(&buff, &len, fp) >= 0 &&
strcmp(buff, "quit\r\n"))
{
if (!(cmd = strdup(buff)))
return (my_perror(EALLOC, FAILURE, 0, fd));
if (!handle_cmd(fd, fp, cmd, pwds))
return (FAILURE);
}
if (!buff || strcmp(buff, "quit\n") || my_free(buff))
return (FAILURE);
if (fclose(fp) == -1)
return (my_perror(ECCLOSE, FAILURE, fd, 0));
return (SUCCESS);
}
int display_prompt(int fd, char **pwds)
{
char *prompt;
int i;
int s;
if (pwds && pwds[HOME])
{
s = strlen(pwds[HOME]);
i = s - 1;
while (--i >= 0 && pwds[HOME][i] != '/');
if (!(prompt = malloc(sizeof(*prompt) * (strlen(EOP) + s - (i + 1)))))
return (my_perror(EALLOC, FAILURE, 0, fd));
strncpy(prompt, pwds[HOME] + i + 1, s - (i + 2));
prompt[s - (i + 2)] = '\0';
strcat(prompt, EOP);
}
else
if (!(prompt = DEFAULT_PROMPT))
return (my_perror(EALLOC, FAILURE, 0, fd));
if (fputstr(fd, prompt) == -1)
return (my_perror(EWRITE, FAILURE, 0, fd));
free(prompt);
return (SUCCESS);
}
int my_user(int fd, FILE *fp, FILE *f_stdin, size_t len)
{
char *buff;
int s;
buff = NULL;
if ((s = getline(&buff, &len, fp)) < 0)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
putcolor(buff);
if ((size_t)s > strlen(buff) && buff[0] != '3' && !my_free(buff))
return (SUCCESS);
putstr("Please enter your password:\n");
if (getline(&buff, &len, f_stdin) < 0 || fputstr(fd, buff) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if (getline(&buff, &len, fp) < 0)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if (buff[strlen(buff) - 2] == '\r' &&
putcolor(buff) && !my_free(buff))
return (SUCCESS);
putstr("Please confirm your password:\n");
if (getline(&buff, &len, f_stdin) < 0 || fputstr(fd, buff) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if (getline(&buff, &len, fp) < 0)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
putcolor(buff);
free(buff);
return (SUCCESS);
}
static int end_main(FILE const *const file, int const output)
{
if (fclose((FILE *)file) != 0)
{
if (close(output) == -1)
my_perror(ERR, CLOSE_OUTPUT_FILE);
return (my_perror(ERR, CLOSE_SYSCALL_FILE));
}
if (close(output) == -1)
return (my_perror(ERR, CLOSE_OUTPUT_FILE));
return (SUCCESS);
}
int check_input_error_and_load(char **ag,
t_list **list, t_game *game)
{
int i;
i = 1;
if ((check_dump(game, ag, &i)) == ERROR)
return (my_perror(ERR_DUMP));
if ((check_input_champ(ag, list, game, i)) == ERROR)
return (my_perror(ERR_IN_CHAMP));
return (GOOD);
}
static int generat_new_syscall(t_list **list,
char const *const name,
char const *const opcode)
{
t_syscall *syscall;
if ((syscall = malloc(sizeof(t_syscall))) == NULL)
return (my_perror(ERR, MALLOC_ERR));
memset(syscall, 0, sizeof(t_syscall));
if ((syscall->name = strdup(name)) == NULL)
return (my_perror(ERR, MALLOC_ERR));
syscall->opcode = atoi(opcode);
return (add_element(list, syscall));
}
int connect_to_server(t_graphic *c)
{
c->server.sin_family = AF_INET;
c->server.sin_port = htons(c->port);
if (((c->socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1 &&
my_perror(SYSCALL("socket"), FAILURE) == FAILURE) ||
(inet_aton(c->ip, IN_ADDR(&c->server.sin_addr.s_addr)) == -1 &&
my_perror(SYSCALL("inet_aton"), FAILURE) == FAILURE) ||
(connect(c->socket, C_SOCKADDR(&c->server), sizeof(c->server)) == -1 &&
my_perror(SYSCALL("connect"), FAILURE) == FAILURE))
return (close_graphic(c, FAILURE));
printf("Graphic trying to connect\n");
return (check_fds(c));
}
lt_http_status_t lt_http_server_destroy( lt_http_server_t * server )
{
if( server == NULL ) return LT_HTTP_INVALID_ARG;
/* close the master socket */
if( APR_SUCCESS != apr_socket_close( server->socket ) ) {
my_perror( "ERROR: apr_socket_close failed with: " );
}
/* close the opened file that has been served */
if( APR_SUCCESS != apr_file_close( server->file ) ) {
my_perror( "ERROR: apr_file_info failed with: " );
}
return LT_HTTP_SUCCESS;
}
/* Write an AVL tree to a file (the opening book), then clear the tree.
Returns 0 if successfull. */
int
write_book(const char *filename, AvlNode *tree)
{
FILE *fp;
ASSERT(1, filename != NULL);
if (tree == NULL)
return -1;
if (!book_modified)
return 0;
if ((fp = fopen(filename, "wb")) == NULL) {
my_perror("Can't open file %s", filename);
return -1;
}
write_avl(tree, fp);
my_close(fp, filename);
update_log("Book file saved: %s", filename);
return 0;
}
static size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
{
struct connection *conn = userdata;
int bytes = size * nmemb;
if (conn->out == -1) {
char *fname;
if (conn->regexp && !conn->matched)
fname = conn->regfname;
else {
if (want_extensions)
/* We allocated space for the extension in add_outname */
strcat(conn->outname, lazy_imgtype(ptr));
fname = conn->outname;
}
if ((conn->out = creat(fname, 0644)) < 0) {
my_perror(fname);
fail_connection(conn);
return bytes;
}
conn->connected = 1;
}
int n = write(conn->out, ptr, bytes);
if (n != bytes)
printf("Write error\n");
return n;
}
void my_putstr(const char *str, int fd, int strlen)
{
int len;
len = 0;
if (str != NULL)
{
if (strlen == -1)
{
while (str[len] != '\0')
len++;
strlen = len;
}
while ((len = write(fd, str, strlen)) != strlen)
{
if (len == -1)
{
my_perror("Write");
return ;
}
str = &(str[len]);
strlen -= len;
}
}
}
/*
** chdir HOME / chdir OLDPWD for cd ~ or cd -
*/
char *my_cd_options(char **env, char *arg)
{
char *var;
char *home;
var = "HOME";
if (arg && arg[0] == '-')
var = "OLDPWD";
if (*env == NULL || (home = my_find_in_env(env, var)) == NULL)
{
msg_error("mysh: cd: ");
msg_error(var);
msg_error(" not set.\n");
return (NULL + 1);
}
if ((home = my_strdup(home)) == NULL)
return (NULL);
if (my_strcmp(var, "HOME"))
{
my_putstr(home);
my_putchar('\n');
}
if (chdir(home) == FAILURE && my_perror(home, 0))
return (NULL + 1);
return (home);
}
static int follow_handle_set(int const socket_fd,
int fd)
{
char buf_size[5];
char buffer[4097];
int size;
size = 1;
while (size != 0)
{
memset(buf_size, 0, 5);
read(socket_fd, buf_size, 4);
size = atoi(buf_size);
if (size == 0)
break ;
memset(buffer, 0, 4097);
read(socket_fd, buffer, size);
write(fd, buffer, size);
}
memset(buffer, 0, 4097);
read(socket_fd, buffer, 4096);
printf("%s", buffer);
write(socket_fd, END_DATA_TR, strlen(END_DATA_TR));
if (close(fd) == -1)
return (my_perror(__func__, __LINE__ - 1, __FILE__, SUCCESS));
return (SUCCESS);
}
int
main(int argc, char **argv)
{
#ifdef EVENT__HAVE_SETRLIMIT
/* Set the fd limit to a low value so that any fd leak is caught without
making many requests. */
struct rlimit rl;
rl.rlim_cur = rl.rlim_max = 20;
if (setrlimit(RLIMIT_NOFILE, &rl) == -1) {
my_perror("setrlimit");
exit(3);
}
#endif
#ifdef _WIN32
WSADATA WSAData;
WSAStartup(0x101, &WSAData);
#endif
/* Set up an address, used by both client & server. */
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = htonl(0x7f000001);
saddr.sin_port = 0; /* Tell the implementation to pick a port. */
start_loop();
return 0;
}
int check_spot_champ(t_list *list, t_game *game)
{
t_list *tmp;
int i;
int tab_spot[5];
i = 0;
while (i < 5)
{
tab_spot[i] = -2;
i = i + 1;
}
i = 0;
tmp = list;
while (tmp)
{
tab_spot[i] = tmp->champ->spot_champ;
tmp = tmp->prev;
i = i + 1;
}
if ((check_spot(tab_spot)) == ERROR)
return (my_perror(ERR_SPOT));
if ((must_init_spot(tab_spot)) == GOOD)
modif_spot(list, tab_spot, game);
return (GOOD);
}
int handle_cmd(int fd, FILE *fps[2], char *buff, char **pwds)
{
size_t len;
int ret;
len = 0;
if ((ret = launch_specific_cmd(fd, fps, buff, pwds)) <= 0)
return (ret);
if (buff[0] && (buff[0] != '\n' || buff[1]))
{
buff = my_free(buff);
while ((ret = getline(&buff, &len, fps[0])) >= 0 && buff[ret - 2] != '\r')
{
if (!strncmp(buff, "150 File status okay", 20))
buff[strlen(buff) - 2] = '\r';
putcolor(buff);
}
putcolor(buff);
free(buff);
return (SUCCESS);
}
buff = my_free(buff);
if (getline(&buff, &len, fps[0]) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
free(buff);
return (SUCCESS);
}
int launch_specific_cmd(int fd, FILE *fps[2], char *buff, char **pwds)
{
char *ret;
ret = NULL + 1;
if (!my_cmdcmp(buff, "HELP") || !my_cmdcmp(buff, "help"))
ret = my_help(buff + 4);
if (!my_cmdcmp(buff, "LLIST"))
ret = my_lls(fd, fps[0], buff + 5, pwds);
if (!my_cmdcmp(buff, "LPWD"))
ret = my_lpwd(fd, fps[0], buff + 4, pwds);
if (!my_cmdcmp(buff, "LCWD"))
ret = my_lcd(fd, fps[0], buff + 4, pwds);
if ((ret != NULL + 1 && !strcpy(buff, "\n")) ||
rfputstr(fd, buff) == -1)
return (my_perror(EUNAVAILABLE, FAILURE, fd, 0));
if (ret == NULL + 1)
{
if (my_cmdcmp(buff, "USER") || my_free(buff))
return (SUCCESS);
if ((fd = my_user(fd, fps[0], fps[1], 0)) == SUCCESS)
return (-1);
return (fd);
}
if (!ret || !putstr(ret) || my_free(ret))
return (FAILURE);
return (SUCCESS);
}
ALWAYS_INLINE static int check_double(t_list *const *const list)
{
t_list *tmp;
t_list *tmp2;
int i;
if ((tmp = *list) == NULL)
return (my_perror(ERR, NO_ELEMENT));
while (tmp != NULL)
{
tmp2 = *list;
i = 0;
while (tmp2 != NULL)
{
if ((strcmp(((t_syscall *)(tmp->data))->name,
((t_syscall *)(tmp2->data))->name) == 0
|| ((t_syscall *)(tmp->data))->opcode
== ((t_syscall *)(tmp2->data))->opcode))
++i;
tmp2 = tmp2->next;
}
if (i != 1)
return (my_error_line(ERR_DOUBLE_SYSCALL,
((t_syscall *)(tmp->data))->name));
tmp = tmp->next;
}
return (SUCCESS);
}
