void new_read(int fd)
{
char rbuf[6];
int i = read (fd, &rbuf, 6);
if (i < 0) {
fprintf (stderr, "Socket: Read error: %s\n", strerror (errno));
} else if (!i) {
clean_fd(fd);
} else {
printf("read New\n");
if (!strncmp(rbuf, "VIEWER", 6)) {
printf("New viewer\n");
fds[fd].type = FD_VIEWER;
fdviewer = fd;
fds[fd].fct_write = viewer_write;
}
else if (!strncmp(rbuf, "CLIENT", 6)) {
printf("New client\n");
fds[fd].type = FD_CLIENT;
fds[fd].fct_read = client_read;
//fds[fd].fct_write = client_write;
}
fds[fd].buf_read.clear();
fds[fd].buf_write.clear();
++cls;
}
}
int pop_fd(t_fd **fds, t_fd *target)
{
int fd;
t_fd *ptr;
char type;
fd = target->fd;
type = target->type;
if (target == *fds)
*fds = target->next;
else
{
ptr = *fds;
while (ptr->next && ptr->next != target)
ptr = ptr->next;
if (!ptr->next)
return (EXIT_SUCCESS);
ptr->next = ptr->next->next;
}
clean_fd(target);
if (close(fd) == -1)
return (msg_error(ECLOSE, 1));
if (type == FD_CLIENT)
printf("server: closing connection with client number %d.\n", fd);
return (EXIT_SUCCESS);
}
void init_env(t_env *e)
{
int i;
e->maxfd = OPEN_MAX;
e->fds = xmalloc(sizeof(*e->fds) * e->maxfd);
i = 0;
while (i < e->maxfd)
{
clean_fd(&e->fds[i]);
i++;
}
return ;
}
void client_read(int cs)
{
int r;
packet buf;
bzero(&buf, sizeof(buf));
r = recv(cs, &buf, sizeof(buf), 0);
if (r <= 0) {
close(cs);
clean_fd(cs);
}
else {
if (buf.flags & B11) {
// robot->addAction(standUp());
// printf("Recv Up!\n");
}
else if (buf.flags & B01) {
// printf("Recv Shot!\n");
}
else if (buf.flags & B12) {
// robot->addAction(standDown());
// printf("Recv Down!\n");
}
else if (buf.flags & B06) {
// printf("Recv clear!\n");
}
else if (buf.flags & B05) {
robot->events.clear();
// printf("Recv clear!\n");
}
if (robot->turn != buf.turn) {
robot->turn = buf.turn;
printf("Recv Turn:%d\n", buf.turn);
}
if (robot->height != buf.height) {
robot->height = buf.height;
// robot->addAction(updateHeight());
// printf("Recv Height:%d\n", buf.height);
}
if (buf.y != robot->y) {
robot->y = buf.y;
printf("Recv y:%d\n", buf.y);
}
if (buf.x != -robot->x) {
robot->x = -buf.x;
printf("Recv x:%d\n", buf.x);
}
}
}
void init_env(t_env *e)
{
int i;
struct rlimit rlp;
X(-1, getrlimit(RLIMIT_NOFILE, &rlp), "getrlimit");
e->maxfd = rlp.rlim_cur;
e->fds = (t_fd*)X(NULL, malloc(sizeof(*e->fds) * e->maxfd), "malloc");
i = 0;
while (i < e->maxfd)
{
clean_fd(&e->fds[i]);
i++;
}
}
void client_read(t_data *data, int cs)
{
int blen;
blen = strlen(data->fds[cs].buf_read);
if (recv(cs, data->fds[cs].buf_read + blen, BUF_SIZE - blen, 0) <= 0)
{
close(cs);
clean_fd(data->fds + cs);
printf("client %d has disconnected\n", cs);
}
else if (data->fds[cs].buf_read[strlen(data->fds[cs].buf_read) - 1]
== '\n')
bufread_handl(data, data->fds[cs].buf_read, cs);
}
void srv_accept(t_env *e, int s)
{
int cs;
struct sockaddr_in csin;
socklen_t csin_len;
csin_len = sizeof(csin);
cs = X(-1, accept(s, (struct sockaddr*)&csin, &csin_len), "accept");
printf("New client #%d from %s:%d\n", cs,
inet_ntoa(csin.sin_addr), ntohs(csin.sin_port));
clean_fd(&e->fds[cs]);
e->fds[cs].type = FD_CLIENT;
e->fds[cs].fct_read = client_read;
e->fds[cs].fct_write = client_write;
}
static void st_clean(t_env *env, char *tmp, int cs)
{
if (cs == env->graphic && ft_strstr(tmp, "seg ") != NULL)
{
printf("END\n");
env->end = YES;
}
ft_lstdel(&(env->fd_socket[cs].line), ft_del);
ft_bzero(env->fd_socket[cs].buf_write, BUF_SIZE);
if (cs != env->graphic
&& env->fd_socket[cs].type == CLIENT
&& ft_strstr(tmp, "mort\n") != NULL)
clean_fd(&env->fd_socket[cs]);
ft_memdel((void **)&tmp);
}
void sv_receive_command(t_sv_prop *sv, int cl)
{
int rd;
int ret_cmd;
if ((rd = E(-1, recv(CL_SOCK(cl), sv->fds[cl].rd, BUF_SIZE, 0), ERR_RECV, NO_EXIT)) > 0)
{
printf("[sv_receive_command] [client : %d] [commande : %s] [lu : %d]\n", cl, sv->fds[cl].rd, rd);
sv->cmd->cmda = lexer(sv->fds[cl].rd);
ret_cmd = execute(sv, cl);
if (!ret_cmd)
pterr(ERR_CMD_NOT_FOUND);
ft_strarray_del(&(sv->cmd->cmda));
//ft_bzero(sv->fds[cl].rd, rd);
ft_bzero(sv->fds[cl].rd, BUF_SIZE + 1);
}
else
clean_fd(&(sv->fds[cl]));
}
void srv_accept(t_env *env, int s)
{
int c_sock;
struct sockaddr_in c_sin;
socklen_t len;
char *buff;
len = sizeof(c_sin);
c_sock = tryint(-1, accept(s, (t_sockaddr *)&c_sin, &len), "accept");
disp_new_client(c_sock, c_sin);
clean_fd(&env->fds[c_sock]);
env->fds[c_sock].type = FD_CLIENT_WAITING;
env->fds[c_sock].fct_read = wait_read;
env->fds[c_sock].fct_write = wait_write;
buff = ft_itoa(c_sock);
env->fds[c_sock].nick = ft_strjoin("#", buff);
setup_ping(env, c_sock);
ringbuff_write(env->fds[c_sock].buf_write, env->fds[c_sock].ping, 5);
ringbuff_write(env->fds[c_sock].buf_write, "\n\r", 2);
free(buff);
}
void srv_accept(t_env *e, int s)
{
int cs;
struct sockaddr_in csin;
socklen_t csin_len;
char buf[4096];
csin_len = sizeof(csin);
cs = X(-1, accept(s, (struct sockaddr*)&csin, &csin_len), "accept");
clean_fd(&e->fds[cs]);
e->fds[cs].type = FD_CLIENT;
e->fds[cs].fct_read = client_read;
e->fds[cs].fct_write = client_write;
e->fds[cs].nicktrue = 0;
e->fds[cs].nick = NULL;
e->fds[cs].noteam = 1;
memcpy(buf, "BIENVENUE\n", BUF_SIZE);
write(cs, buf, ft_strlen(buf));
srv_accept_(cs, e);
return ;
}
void client_read(t_env *e, int cs)
{
int r;
int i;
r = recv(cs, e->fds[cs].buf_read, BUF_SIZE, 0);
if (r <= 0)
{
close(cs);
clean_fd(&e->fds[cs]);
printf("client #%d gone away\n", cs);
}
else
{
i = 0;
while (i < e->maxfd)
{
if ((e->fds[i].type == FD_CLIENT) &&
(i != cs))
send(i, e->fds[cs].buf_read, r, 0);
i++;
}
}
}
