int free_before_reset(t_server *server)
{
if (!server)
return (0);
if (remove_players_from_team(server) == -1)
return (-1);
free_list(server->data.eggs, 0);
free_clients(server->queue_clients, 0, 0);
free_clients(server->graphic_clients, 0, 0);
free_clients(server->all_players, 1, 0);
return (0);
}
void free_infos(t_server *infos)
{
uint32_t i;
free_clients(infos);
free_eggs(infos);
free_clients_team_name(infos);
free_incantation(infos);
if (infos->teams_names != NULL)
{
i = 0;
while (infos->teams_names[i] != NULL)
{
free(infos->teams_names[i]);
++i;
}
free(infos->teams_names);
infos->teams_names = NULL;
}
free(infos->map);
infos->map = NULL;
free(infos->nb_players_team);
infos->nb_players_team = NULL;
free(infos->network.local_ip);
infos->network.local_ip = NULL;
free(infos->network.fds);
infos->network.fds = NULL;
}
/**
* Executa o comando CLOSE
* @param server
* @param socket
* @param msg
* @param addr
* @param port
*/
void run_close(Server* server, Socket socket, char* msg, char* addr, int port){
Client* from = find_user_by_host_port(server->client_list, addr, port);
if(from == NULL){
send_message(socket, addr, port, "CLOSE not registered\n");
return;
}
Client* prev;
for(prev = server->client_list; prev->next != NULL; prev = prev->next){
if(prev->next == from){
break;
}
}
//Remove o usuario da lista de clientes
if(server->client_list == from){
server->client_list = from->next;
from->next = NULL;
}else{
prev->next = from->next;
from->next = NULL;
}
free_clients(from);
send_message(socket, addr, port, "CLOSE success\n");
}
int free_all(t_server *server, int const ret_value)
{
if (!server)
return (ret_value);
free_list(server->data.eggs, ret_value);
free_teams(server->data.teams, ret_value);
free_clients(server->queue_clients, 0, ret_value);
free_clients(server->graphic_clients, 0, ret_value);
free_clients(server->all_players, 1, ret_value);
free_int_tab(server->data.required_players, ret_value);
free_int_tab(server->data.ports, ret_value);
free_int_tab(server->socks, ret_value);
free_double_int_tab(server->data.resources, ret_value);
free(server->data.timers);
return (free_map(server->data.map, ret_value));
}
/*
* Free the contents of a single group_t.
*/
static void
free_group(group_t *group)
{
if (group) {
free_phcis(group->nphcis, group->phcis);
free_clients(group->nclients, group->clients);
free(group);
}
}
void destroy(t_server *server)
{
free_teams(server->teams);
free_clients(server->clients);
free_map(server->map);
free(server);
printf("Bye.\n");
}
static void free_provider(provider_t *p) {
if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fileno(p->file), NULL) < 0) {
fprintf(stderr, "epoll_ctl: %s\n", strerror(errno));
exit(1);
}
free(p->command);
fclose(p->file);
free(p->header);
free_clients(p->clients);
free(p);
}
void cleanup()
{
DEBUG(printf("cleanup\n"));
if(screen_fd)
close(screen_fd);
if(aux_fd)
close(aux_fd);
if(power_fd)
close(power_fd);
if(sock)
close(sock);
free(screen_dev);
free(aux_dev);
free(power_dev);
free(pfds);
free_clients();
}
/**
* Executa o comando NICK
* @param server
* @param socket
* @param msg
* @param addr
* @param port
*/
void run_nick(Server* server, Socket socket, char* msg, char* addr, int port){
char username[20];
char command[10];
//estrai o comando e o nome de usuario da mensagem
sscanf(msg, "%s%s", command, username);
Client* c = new_client(username, addr, port);
Client** last;
//verifica se o nome de usuario ja esta em uso
for(last = &server->client_list; *last != NULL; last = &(*last)->next){
if(strcmp(username, (*last)->username) == 0){
send_message(socket, addr, port, "NICK taken\n");
free_clients(c);
return;
}
}
*last = c;
send_message(socket, addr, port, "NICK success\n");
}
static int
get_affected_clients(rcm_handle_t *hdl, char *rsrc, int cmd, int flags,
char ***clientsp)
{
int nclients = 0;
phci_t phci;
group_t *group;
char **clients = NULL;
/* Build a dummy phci_t for use with bsearch(). */
phci.path = rsrc;
/* Analyze the effects upon each group. */
for (group = group_list; group != NULL; group = group->next) {
/* If the PHCI isn't in the group, then no effects. Skip. */
if (bsearch(&phci, group->phcis, group->nphcis, sizeof (phci_t),
compare_phci) == NULL)
continue;
/*
* Merge in the clients. All clients are merged in for getinfo
* operations. Otherwise it's contingent upon a state change
* being transferred to the clients as a result of changing
* the PHCI's state.
*/
if ((cmd == CMD_GETINFO) ||
detect_client_change(hdl, cmd, flags, group, rsrc)) {
if (merge_clients(&nclients, &clients, group) < 0) {
free_clients(nclients, clients);
return (-1);
}
}
}
/* Return the array of affected disks */
*clientsp = clients;
return (0);
}
void shutdown_server(Server* server){
free_clients(server->client_list);
free(server);
}
