static void rankings_free(void *pstat)
{
GGZRanking *ranking = pstat;
ggz_free(ranking->name);
ggz_free(ranking);
}
void _ggzcore_player_free(GGZPlayer * player)
{
if (player->name)
ggz_free(player->name);
ggz_free(player);
}
static void infos_free(void *pstat)
{
GGZPlayerInfo *info = pstat;
ggz_free(info->realname);
ggz_free(info->photo);
ggz_free(info->host);
ggz_free(info);
}
int main(void)
{
int errs = 0;
char *instr, *outstr;
/* Make sure a character is one byte. I believe C specs say
this is always the case, so it probably isn't necessary to
check. But it can't hurt. */
if (sizeof(char) != 1) {
printf("'char' must have size 1.\n");
errs++;
}
instr = TESTSTR1;
outstr = ggz_xml_escape(instr);
printf("Input string = %s\n", instr);
printf("Output string = %s\n", outstr);
instr = ggz_xml_unescape(outstr);
printf("Back to input string = %s\n", instr);
if(strcmp(instr, TESTSTR1)) {
printf("Output doesn't match original!\n");
errs++;
}
ggz_free(instr);
ggz_free(outstr);
instr = TESTSTR2;
outstr = ggz_xml_escape(instr);
printf("Input string = %s\n", instr);
printf("Output string = %s\n", outstr);
if(strcmp(outstr, instr)) {
printf("Conversion doesn't match original!\n");
errs++;
}
instr = ggz_xml_unescape(outstr);
printf("Back to input string = %s\n", instr);
if(strcmp(instr, TESTSTR2)) {
printf("Output doesn't match original!\n");
errs++;
}
ggz_free(instr);
ggz_free(outstr);
ggz_memory_check();
if(errs == 0)
printf("All tests successful\n");
else
printf("Failed tests = %d\n", errs);
return errs;
}
static int _io_read_msg_chat(GGZMod *ggzmod)
{
char *player, *chat;
if (ggz_read_string_alloc(ggzmod->fd, &player) < 0
|| ggz_read_string_alloc(ggzmod->fd, &chat) < 0)
return -1;
_ggzmod_handle_chat(ggzmod, player, chat);
ggz_free(player);
ggz_free(chat);
return 0;
}
void table_cleanup(void)
{
int p;
/* This doesn't clean up all the GTK stuff, only the ggz_malloc'd
stuff so that the memory check will be clean. */
for (p = 0; p < MAX_NUM_PLAYERS; p++) {
if (player_names[p] != NULL)
ggz_free(player_names[p]);
if (player_messages[p] != NULL)
ggz_free(player_messages[p]);
player_names[p] = player_messages[p] = NULL;
}
}
static void put_global_message(char *mark, char *msg)
{
global_message_list_t *gml;
ggz_debug(DBG_MISC,
"Setting global message for '%s'. Length is %zd.", mark,
strlen(msg));
if (!mark || !msg)
ggz_error_msg("put_global_message called on NULL string.");
for (gml = game.message_head; gml != NULL; gml = gml->next) {
if (!strcmp(mark, gml->mark)) {
ggz_free(gml->message);
gml->message = ggz_strdup(msg);
return;
}
}
gml = ggz_malloc(sizeof(global_message_list_t));
gml->mark = ggz_strdup(mark);
gml->message = ggz_strdup(msg);
if (game.message_tail)
game.message_tail->next = gml;
game.message_tail = gml;
if (!game.message_head)
game.message_head = gml;
}
/* Let grubby speak */
void net_output(Guru *output)
{
char *token;
char *msg;
if(!room) return;
/* Handle multi-line answers */
if(!output->message) return;
msg = ggz_strdup(output->message);
token = strtok(msg, "\n");
while(token)
{
switch(output->type)
{
case GURU_CHAT:
case GURU_DIRECT:
ggzcore_room_chat(room, GGZ_CHAT_NORMAL, NULL, token);
break;
case GURU_PRIVMSG:
ggzcore_room_chat(room, GGZ_CHAT_PERSONAL, output->player, token);
break;
case GURU_ADMIN:
ggzcore_room_chat(room, GGZ_CHAT_ANNOUNCE, NULL, token);
break;
case GURU_GAME:
ggzcore_room_chat(room, GGZ_CHAT_NORMAL, NULL, token);
net_internal_gameprepare(output->player);
break;
}
token = strtok(NULL, "\n");
}
ggz_free(msg);
}
/* Let grubby speak */
void net_output(Guru *output)
{
char *token;
char *msg;
/* Handle multi-line answers */
if(!output->message) return;
msg = ggz_strdup(output->message);
token = strtok(msg, "\r\n");
while(token)
{
switch(output->type)
{
case GURU_CHAT:
fprintf(irc, "PRIVMSG %s :%s\r\n", chatroom, token);
fflush(irc);
break;
case GURU_PRIVMSG:
fprintf(irc, "PRIVMSG %s :%s\r\n", output->player, token);
break;
case GURU_ADMIN:
fprintf(irc, "PRIVMSG %s :[admin] %s\n", output->player, token);
break;
}
token = strtok(NULL, "\n");
}
ggz_free(msg);
}
void _ggzcore_server_change_state(GGZServer * server, GGZTransID trans)
{
if (trans == GGZ_TRANS_NET_ERROR || trans == GGZ_TRANS_PROTO_ERROR) {
#ifdef SUPPORT_RECONNECT
if (reconnect_policy) {
char *host;
int port;
GGZConnectionPolicy policy;
ggz_debug(GGZCORE_DBG_SERVER, "Setting up reconnection attempt");
reconnect_server = server;
host = ggz_strdup(_ggzcore_net_get_host(server->net));
port = _ggzcore_net_get_port(server->net);
policy = _ggzcore_net_get_policy(server->net);
_ggzcore_net_free(server->net);
server->net = _ggzcore_net_new();
_ggzcore_net_init(server->net, server, host, port, policy);
ggz_free(host);
_ggzcore_server_clear_reconnect(server);
server->state = GGZ_STATE_RECONNECTING;
_ggzcore_server_event(server, GGZ_STATE_CHANGE, NULL);
signal(SIGALRM, reconnect_alarm);
alarm(reconnect_timeout);
return;
}
#endif
}
_ggzcore_state_transition(trans, &server->state);
_ggzcore_server_event(server, GGZ_STATE_CHANGE, NULL);
}
void _ggzcore_server_free(GGZServer * server)
{
if (server->game)
ggzcore_game_free(server->game);
_ggzcore_server_clear(server);
ggz_free(server);
}
void _ggzcore_server_clear(GGZServer * server)
{
int i;
/* Clear all members */
if (server->net) {
_ggzcore_net_free(server->net);
server->net = NULL;
}
if (server->channel) {
if (!server->is_channel) {
_ggzcore_net_free(server->channel);
}
server->channel = NULL;
}
if (server->handle) {
ggz_free(server->handle);
server->handle = NULL;
}
if (server->password) {
ggz_free(server->password);
server->password = NULL;
}
if (server->rooms) {
_ggzcore_server_free_roomlist(server);
server->rooms = NULL;
server->num_rooms = 0;
}
server->room = NULL;
if (server->gametypes) {
_ggzcore_server_free_typelist(server);
server->gametypes = NULL;
server->num_gametypes = 0;
}
for (i = 0; i < GGZ_NUM_SERVER_EVENTS; i++) {
if (server->event_hooks[i]) {
_ggzcore_hook_list_destroy(server->event_hooks[i]);
server->event_hooks[i] = NULL;
}
}
}
void _ggzcore_server_set_email(GGZServer * server, const char *email)
{
/* Free old email if one existed */
if (server->email)
ggz_free(server->email);
server->email = ggz_strdup(email);
}
void _ggzcore_server_set_password(GGZServer * server, const char *password)
{
/* Free old password if one existed */
if (server->password)
ggz_free(server->password);
server->password = ggz_strdup(password);
}
void _ggzcore_server_set_handle(GGZServer * server, const char *handle)
{
/* Free old handle if one existed */
if (server->handle)
ggz_free(server->handle);
server->handle = ggz_strdup(handle);
}
static int _io_read_msg_server(GGZMod *ggzmod)
{
char *host = NULL, *handle = NULL;
int port;
if (ggz_read_string_alloc(ggzmod->fd, &host) < 0
|| ggz_read_int(ggzmod->fd, &port) < 0
|| ggz_read_string_alloc(ggzmod->fd, &handle) < 0) {
if (host) ggz_free(host);
if (handle) ggz_free(handle);
return -1;
}
_ggzmod_handle_server(ggzmod, host, port, handle);
ggz_free(host);
ggz_free(handle);
return 0;
}
static void server_free_node(gpointer server_ptr, gpointer data)
{
const Server *server = server_ptr;
if (server->name)
ggz_free(server->name);
if (server->host)
ggz_free(server->host);
if (server->login)
ggz_free(server->login);
if (server->password)
ggz_free(server->password);
ggz_free(server);
}
/* FIXME: Provide real queue */
static void net_internal_queueadd(const char *player, const char *message, int type, int playertype)
{
Guru *guru;
char *listtoken;
char *token;
int i;
char realmessage[1024];
/* Add dummy field on dummy messages */
if((message) && (type == GURU_PRIVMSG))
{
snprintf(realmessage, sizeof(realmessage), "%s %s", guruname, message);
message = realmessage;
}
/* Insert new grubby structure */
guru = (Guru*)ggz_malloc(sizeof(Guru));
guru->type = type;
if(player) guru->player = ggz_strdup(player);
else guru->player = NULL;
guru->playertype = playertype;
if(message)
{
guru->message = ggz_strdup(message);
guru->list = NULL;
listtoken = ggz_strdup(message);
token = strtok(listtoken, " ,./:?!\'");
i = 0;
while(token)
{
guru->list = (char**)ggz_realloc(guru->list, (i + 2) * sizeof(char*));
guru->list[i] = (char*)ggz_malloc(strlen(token) + 1);
strcpy(guru->list[i], token);
guru->list[i + 1] = NULL;
i++;
token = strtok(NULL, " ,./:?!\'");
}
ggz_free(listtoken);
}
else
{
guru->message = NULL;
guru->list = NULL;
}
/* Recognize direct speech */
if((guru->type == GURU_CHAT) && (guru->list) && (guru->list[0]))
if(!strcasecmp(guru->list[0], guruname))
guru->type = GURU_DIRECT;
/* Insert structure into queue */
queuelen++;
queue = (Guru**)ggz_realloc(queue, sizeof(Guru*) * queuelen);
queue[queuelen - 2] = guru;
queue[queuelen - 1] = NULL;
}
int velena_ai_move(int column)
{
char *boardstr = ggz_strbuild("%s%i", board, column);
ggz_strncpy(board, boardstr, sizeof(board));
ggz_free(boardstr);
/* FIXME: how can we know if a player move succeeded? */
/* -> check min/max column at least */
return 1;
}
void _ggzcore_server_free_typelist(GGZServer * server)
{
int i;
for (i = 0; i < server->num_gametypes; i++) {
_ggzcore_gametype_free(server->gametypes[i]);
}
ggz_free(server->gametypes);
server->num_gametypes = 0;
}
void send_last_hand(void)
{
int *lengths = ggz_malloc(game.num_seats * sizeof(*lengths));
card_t **cardlist = ggz_malloc(game.num_seats * sizeof(*cardlist));
hand_t *hand;
seat_t s;
for (s = 0; s < game.num_seats; s++) {
hand = &game.seats[s].hand;
hand->hand_size = hand->full_hand_size;
cards_sort_hand(hand);
lengths[s] = hand->full_hand_size;
cardlist[s] = hand->cards;
}
net_broadcast_global_cardlist_message("Previous Hand", lengths, cardlist);
ggz_free(lengths);
ggz_free(cardlist);
}
/* Displays a player's message on the table. */
void table_set_player_message(int player, const char *message)
{
ggz_debug(DBG_TABLE, "Setting player message for %d.", player);
if (player_messages[player])
ggz_free(player_messages[player]);
player_messages[player] = ggz_strdup(message);
if (table_ready)
table_show_player_box(player, TRUE);
}
/* Display's a player's name on the table. */
void table_set_name(int player, const char *name)
{
ggz_debug(DBG_TABLE, "Setting player name: %d => %s.", player,
name);
if (player_names[player])
ggz_free(player_names[player]);
player_names[player] = ggz_strdup(name);
if (table_ready)
table_show_player_box(player, TRUE);
}
void send_last_trick(void)
{
int *lengths = ggz_malloc(game.num_seats * sizeof(*lengths));
card_t **cardlist = ggz_malloc(game.num_seats * sizeof(*cardlist));
card_t *cardlist2 = ggz_malloc(game.num_seats * sizeof(*cardlist2));
seat_t s;
for (s = 0; s < game.num_seats; s++) {
if (game.seats[s].player >= 0) {
lengths[s] = 1;
cardlist[s] = &cardlist2[s];
cardlist[s][0] = game.seats[s].table;
} else
lengths[s] = 0;
}
net_broadcast_global_cardlist_message("Last Trick", lengths, cardlist);
ggz_free(lengths);
ggz_free(cardlist);
ggz_free(cardlist2);
}
void _ggzcore_server_free_roomlist(GGZServer * server)
{
int i;
if (!server->rooms)
return;
for (i = 0; i < server->num_rooms; i++) {
if (server->rooms[i])
_ggzcore_room_free(server->rooms[i]);
}
ggz_free(server->rooms);
server->num_rooms = 0;
}
static int _io_read_msg_player(GGZMod *ggzmod)
{
int is_spectator, seat_num;
char *name;
if (ggz_read_string_alloc_null(ggzmod->fd, &name) < 0
|| ggz_read_int(ggzmod->fd, &is_spectator) < 0
|| ggz_read_int(ggzmod->fd, &seat_num) < 0)
return -1;
_ggzmod_handle_player(ggzmod, name,
is_spectator, seat_num);
if(name)
ggz_free(name);
return 0;
}
static int _io_read_msg_spectator_seat(GGZMod *ggzmod)
{
GGZSpectatorSeat seat;
char *name;
if (ggz_read_int(ggzmod->fd, (int*)&seat.num) < 0
|| ggz_read_string_alloc_null(ggzmod->fd, &name) < 0)
return -1;
seat.name = name;
_ggzmod_handle_spectator_seat(ggzmod, &seat);
if (seat.name)
ggz_free(seat.name);
return 0;
}
/* Transparently connect to any host */
void net_connect(const char *host, int port, const char *name, const char *password)
{
guruname = (char*)name;
gurupassword = (char*)password;
GGZCoreMainLoop mainloop;
if(password)
mainloop.uri = ggz_strbuild("ggz://%s:%s@%s:%i", name, password, host, port);
else
mainloop.uri = ggz_strbuild("ggz://%s@%s:%i", name, host, port);
mainloop.reconnect = 1;
mainloop.loop = 1;
mainloop.func = mainloopfunc;
(void)ggzcore_mainloop_start(mainloop);
ggz_free(mainloop.uri);
}
void server_profiles_load(void)
{
guint i, count;
char** profiles;
Server* server;
/* Clear any previous list */
if (servers) {
g_list_foreach(servers, server_free_node, NULL);
g_list_free(servers);
servers = NULL;
}
/* Clear list of deleted servers */
if (deleted) {
g_list_foreach(deleted, server_free_node, NULL);
g_list_free(deleted);
deleted = NULL;
}
ggzcore_conf_read_list("Servers", "ProfileList", (int*)&count, &profiles);
for (i = 0; i < count; i++) {
server = ggz_malloc(sizeof(Server));
server->name = profiles[i];
server->host = ggzcore_conf_read_string(server->name, "Host", NULL);
server->port = ggzcore_conf_read_int(server->name, "Port", 5688);
server->type = ggzcore_conf_read_int(server->name, "Type",
GGZ_LOGIN_GUEST);
server->login = ggzcore_conf_read_string(server->name, "Login", NULL);
if (server->type == GGZ_LOGIN)
server->password = ggzcore_conf_read_string(server->name,
"Password", NULL);
server_list_add(server);
}
server_list_print();
if (profiles)
ggz_free(profiles);
}
static int _io_read_msg_seat(GGZMod *ggzmod)
{
GGZSeat seat;
char *name;
int type;
if (ggz_read_int(ggzmod->fd, (int*)&seat.num) < 0
|| ggz_read_int(ggzmod->fd, &type) < 0
|| ggz_read_string_alloc_null(ggzmod->fd, &name) < 0)
return -1;
/* Set seat values */
seat.type = type;
seat.name = name;
_ggzmod_handle_seat(ggzmod, &seat);
if (seat.name)
ggz_free(seat.name);
return 0;
}
