/**************************************************************************
This function is called when the client received a new input from the
server.
**************************************************************************/
void input_from_server(int fd)
{
int nb;
fc_assert_ret(fd == client.conn.sock);
nb = read_from_connection(&client.conn, FALSE);
if (0 <= nb) {
enum packet_type type;
agents_freeze_hint();
while (client.conn.used) {
bool result;
void *packet = get_packet_from_connection(&client.conn,
&type, &result);
if (result) {
fc_assert_action(packet != NULL, break);
client_packet_input(packet, type);
free(packet);
} else {
fc_assert(packet == NULL);
break;
}
}
if (client.conn.used) {
agents_thaw_hint();
}
} else if (-2 == nb) {
/**************************************************************************
This function is called when the client received a new input from the
server.
**************************************************************************/
void input_from_server(int fd)
{
assert(fd == client.conn.sock);
if (read_from_connection(&client.conn, FALSE) >= 0) {
enum packet_type type;
while (TRUE) {
bool result;
void *packet = get_packet_from_connection(&client.conn,
&type, &result);
if (result) {
assert(packet != NULL);
client_packet_input(packet, type);
free(packet);
} else {
assert(packet == NULL);
break;
}
}
} else {
close_socket_callback(&client.conn);
}
}
/**************************************************************************
This function will sniff at the given fd, get the packet and call
client_packet_input. It will return if there is a network error or if
the PACKET_PROCESSING_FINISHED packet for the given request is
received.
**************************************************************************/
void input_from_server_till_request_got_processed(int fd,
int expected_request_id)
{
assert(expected_request_id);
assert(fd == client.conn.sock);
freelog(LOG_DEBUG,
"input_from_server_till_request_got_processed("
"expected_request_id=%d)", expected_request_id);
while (TRUE) {
if (read_from_connection(&client.conn, TRUE) >= 0) {
enum packet_type type;
while (TRUE) {
bool result;
void *packet = get_packet_from_connection(&client.conn,
&type, &result);
if (!result) {
assert(packet == NULL);
break;
}
assert(packet != NULL);
client_packet_input(packet, type);
free(packet);
if (type == PACKET_PROCESSING_FINISHED) {
freelog(LOG_DEBUG, "ifstrgp: expect=%d, seen=%d",
expected_request_id,
client.conn.client.last_processed_request_id_seen);
if (client.conn.client.last_processed_request_id_seen >=
expected_request_id) {
freelog(LOG_DEBUG, "ifstrgp: got it; returning");
return;
}
}
}
} else {
close_socket_callback(&client.conn);
break;
}
}
}
/**************************************************************************
...
**************************************************************************/
void get_net_input(XtPointer client_data, int *fid, XtInputId *id)
{
if(read_socket_data(*fid, &aconnection.buffer)>0) {
int type;
char *packet;
while((packet=get_packet_from_connection(&aconnection, &type))) {
handle_packet_input(packet, type);
}
}
else {
char buf[512];
sprintf(buf, "Lost connection to server! Quit and reconnect with\n\
the option \"-n %s\", when ready..", game.player_ptr->name);
append_output_window(buf);
log(LOG_NORMAL, "lost connection to server");
close(*fid);
remove_net_input();
}
}
/**************************************************************************
presult indicates if there is more packets in the cache. We return result
instead of just testing if the returning package is NULL as we sometimes
return a NULL packet even if everything is OK (receive_packet_goto_route).
**************************************************************************/
void *get_packet_from_connection(struct connection *pc,
enum packet_type *ptype, bool * presult)
{
int len_read;
int whole_packet_len;
struct {
enum packet_type type;
int itype;
} utype;
struct data_in din;
#ifdef USE_COMPRESSION
bool compressed_packet = FALSE;
int header_size = 0;
#endif
*presult = FALSE;
if (!pc->used) {
return NULL; /* connection was closed, stop reading */
}
if (pc->buffer->ndata < 3) {
return NULL; /* length and type not read */
}
dio_input_init(&din, pc->buffer->data, pc->buffer->ndata);
dio_get_uint16(&din, &len_read);
/* The non-compressed case */
whole_packet_len = len_read;
#ifdef USE_COMPRESSION
if (len_read == JUMBO_SIZE) {
compressed_packet = TRUE;
header_size = 6;
if (dio_input_remaining(&din) >= 4) {
dio_get_uint32(&din, &whole_packet_len);
log_compress("COMPRESS: got a jumbo packet of size %d",
whole_packet_len);
} else {
/* to return NULL below */
whole_packet_len = 6;
}
} else if (len_read >= COMPRESSION_BORDER) {
compressed_packet = TRUE;
header_size = 2;
whole_packet_len = len_read - COMPRESSION_BORDER;
log_compress("COMPRESS: got a normal packet of size %d",
whole_packet_len);
}
#endif
if ((unsigned)whole_packet_len > pc->buffer->ndata) {
return NULL; /* not all data has been read */
}
#ifdef USE_COMPRESSION
if (compressed_packet) {
uLong compressed_size = whole_packet_len - header_size;
/*
* We don't know the decompressed size. We assume a bad case
* here: an expansion by an factor of 100.
*/
unsigned long int decompressed_size = 100 * compressed_size;
void *decompressed = fc_malloc(decompressed_size);
int error;
struct socket_packet_buffer *buffer = pc->buffer;
error =
uncompress(decompressed, &decompressed_size,
ADD_TO_POINTER(buffer->data, header_size),
compressed_size);
if (error != Z_OK) {
log_verbose("Uncompressing of the packet stream failed. "
"The connection will be closed now.");
connection_close(pc, _("decoding error"));
return NULL;
}
buffer->ndata -= whole_packet_len;
/*
* Remove the packet with the compressed data and shift all the
* remaining data to the front.
*/
memmove(buffer->data, buffer->data + whole_packet_len, buffer->ndata);
if (buffer->ndata + decompressed_size > buffer->nsize) {
buffer->nsize += decompressed_size;
buffer->data = fc_realloc(buffer->data, buffer->nsize);
}
/*
* Make place for the uncompressed data by moving the remaining
* data.
*/
memmove(buffer->data + decompressed_size, buffer->data, buffer->ndata);
/*
* Copy the uncompressed data.
*/
memcpy(buffer->data, decompressed, decompressed_size);
free(decompressed);
buffer->ndata += decompressed_size;
log_compress("COMPRESS: decompressed %ld into %ld",
compressed_size, decompressed_size);
return get_packet_from_connection(pc, ptype, presult);
}
#endif
/*
* At this point the packet is a plain uncompressed one. These have
* to have to be at least 3 bytes in size.
*/
if (whole_packet_len < 3) {
log_verbose("The packet stream is corrupt. The connection "
"will be closed now.");
connection_close(pc, _("decoding error"));
return NULL;
}
dio_get_uint8(&din, &utype.itype);
utype.type = utype.itype;
log_packet("got packet type=(%s)%d len=%d from %s",
packet_name(utype.type), utype.itype, whole_packet_len,
is_server() ? pc->username : "******");
*ptype = utype.type;
*presult = TRUE;
if (pc->incoming_packet_notify) {
pc->incoming_packet_notify(pc, utype.type, whole_packet_len);
}
#if PACKET_SIZE_STATISTICS
{
static struct {
int counter;
int size;
} packets_stats[PACKET_LAST];
static int packet_counter = 0;
int packet_type = utype.itype;
int size = whole_packet_len;
if (!packet_counter) {
int i;
for (i = 0; i < PACKET_LAST; i++) {
packets_stats[i].counter = 0;
packets_stats[i].size = 0;
}
}
packets_stats[packet_type].counter++;
packets_stats[packet_type].size += size;
packet_counter++;
if (packet_counter % 100 == 0) {
int i, sum = 0;
log_test("Received packets:");
for (i = 0; i < PACKET_LAST; i++) {
if (packets_stats[i].counter == 0)
continue;
sum += packets_stats[i].size;
log_test(" [%-25.25s %3d]: %6d packets; %8d bytes total; "
"%5d bytes/packet average",
packet_name(i), i, packets_stats[i].counter,
packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter);
}
log_test("received %d bytes in %d packets;average size "
"per packet %d bytes",
sum, packet_counter, sum / packet_counter);
}
}
#endif
return get_packet_from_connection_helper(pc, utype.type);
}