void netcom_base::process_message_(in_packet_t&& p) {
packet_id_t id;
p >> id;
if (debug_packets) {
out_.print("<", p.from, ": ", get_packet_name(id), " (id=", id, ")");
}
auto iter = message_signals_.find(id);
if (iter == message_signals_.end() || (*iter)->empty()) {
if (id != message::unhandled_message::packet_id__ &&
id != message::unhandled_request::packet_id__ &&
id != message::unhandled_request_answer::packet_id__) {
if (!is_packet_id(id)) {
throw netcom_exception::invalid_packet_id(id);
}
if (debug_packets) {
out_.print(" -> unhandled");
}
out_packet_t tp = create_message(make_packet<message::unhandled_message>(id));
in_packet_t& itp = tp.to_input();
netcom_impl::packet_type t; itp >> t; // Trash packet type
process_message_(std::move(itp));
}
} else {
/**************************************************************************
It returns the request id of the outgoing packet (or 0 if pc->is_server).
**************************************************************************/
int send_packet_data(struct connection *pc, unsigned char *data, int len)
{
/* default for the server */
int result = 0;
freelog(BASIC_PACKET_LOG_LEVEL, "sending packet type=%s(%d) len=%d",
get_packet_name(data[2]), data[2], len);
if (!pc->is_server) {
pc->client.last_request_id_used =
get_next_request_id(pc->client.last_request_id_used);
result = pc->client.last_request_id_used;
freelog(BASIC_PACKET_LOG_LEVEL, "sending request %d", result);
}
if (pc->outgoing_packet_notify) {
pc->outgoing_packet_notify(pc, data[2], len, result);
}
#ifdef USE_COMPRESSION
if(TRUE) {
static int stat_size_alone, stat_size_uncompressed, stat_size_compressed,
stat_size_no_compression;
static bool compression_level_initialized = FALSE;
static int compression_level;
int packet_type = data[2];
int size = len;
if (!compression_level_initialized) {
char *s = getenv("FREECIV_COMPRESSION_LEVEL");
if (!s || sscanf(s, "%d", &compression_level) != 1
|| compression_level < -1 || compression_level > 9) {
compression_level = -1;
}
compression_level_initialized = TRUE;
}
/* TODO: PACKET_FREEZE_HINT and PACKET_THAW_HINT are meaningful
* only internally. They should not be sent to connection at all.
* Freezing could also be handled via separate functions, and
* not by special packets.
* Only problem is backward compatibility, so this cannot be
* changed in stable branch. */
if (packet_type == PACKET_PROCESSING_STARTED
|| packet_type == PACKET_FREEZE_HINT) {
if (pc->compression.frozen_level == 0) {
byte_vector_reserve(&pc->compression.queue, 0);
}
pc->compression.frozen_level++;
}
if (pc->compression.frozen_level > 0) {
size_t old_size = pc->compression.queue.size;
byte_vector_reserve(&pc->compression.queue, old_size + len);
memcpy(pc->compression.queue.p + old_size, data, len);
freelog(COMPRESS2_LOG_LEVEL, "COMPRESS: putting %s into the queue",
get_packet_name(packet_type));
} else {
stat_size_alone += size;
freelog(COMPRESS_LOG_LEVEL, "COMPRESS: sending %s alone (%d bytes total)",
get_packet_name(packet_type), stat_size_alone);
send_connection_data(pc, data, len);
}
if (packet_type ==
PACKET_PROCESSING_FINISHED || packet_type == PACKET_THAW_HINT) {
pc->compression.frozen_level--;
if (pc->compression.frozen_level == 0) {
uLongf compressed_size = 12 + pc->compression.queue.size * 1.001;
int error;
Bytef compressed[compressed_size];
error =
compress2(compressed, &compressed_size,
pc->compression.queue.p, pc->compression.queue.size,
compression_level);
assert(error == Z_OK);
if (compressed_size + 2 < pc->compression.queue.size) {
struct data_out dout;
freelog(COMPRESS_LOG_LEVEL,
"COMPRESS: compressed %lu bytes to %ld (level %d)",
(unsigned long)pc->compression.queue.size, compressed_size,
compression_level);
stat_size_uncompressed += pc->compression.queue.size;
stat_size_compressed += compressed_size;
if (compressed_size <= JUMBO_BORDER) {
unsigned char header[2];
freelog(COMPRESS_LOG_LEVEL, "COMPRESS: sending %ld as normal",
compressed_size);
dio_output_init(&dout, header, sizeof(header));
dio_put_uint16(&dout, 2 + compressed_size + COMPRESSION_BORDER);
send_connection_data(pc, header, sizeof(header));
send_connection_data(pc, compressed, compressed_size);
} else {
unsigned char header[6];
freelog(COMPRESS_LOG_LEVEL, "COMPRESS: sending %ld as jumbo",
compressed_size);
dio_output_init(&dout, header, sizeof(header));
dio_put_uint16(&dout, JUMBO_SIZE);
dio_put_uint32(&dout, 6 + compressed_size);
send_connection_data(pc, header, sizeof(header));
send_connection_data(pc, compressed, compressed_size);
}
} else {
freelog(COMPRESS_LOG_LEVEL,
"COMPRESS: would enlarging %lu bytes to %ld; sending uncompressed",
(unsigned long)pc->compression.queue.size, compressed_size);
send_connection_data(pc, pc->compression.queue.p,
pc->compression.queue.size);
stat_size_no_compression += pc->compression.queue.size;
}
}
}
freelog(COMPRESS2_LOG_LEVEL,
"COMPRESS: STATS: alone=%d compression-expand=%d compression (before/after) = %d/%d",
stat_size_alone, stat_size_no_compression,
stat_size_uncompressed, stat_size_compressed);
}
#else
send_connection_data(pc, data, len);
#endif
#if PACKET_SIZE_STATISTICS
{
static struct {
int counter;
int size;
} packets_stats[PACKET_LAST];
static int packet_counter = 0;
static int last_start_turn_seen = -1;
static bool start_turn_seen = FALSE;
int packet_type = data[2];
int size = len;
bool print = FALSE;
bool clear = FALSE;
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_type == PACKET_START_TURN
&& last_start_turn_seen != game.turn) {
start_turn_seen=TRUE;
last_start_turn_seen = game.turn;
}
if ((packet_type ==
PACKET_PROCESSING_FINISHED || packet_type == PACKET_THAW_HINT)
&& start_turn_seen) {
start_turn_seen = FALSE;
print = TRUE;
clear = TRUE;
}
if(print) {
int i, sum = 0;
int ll = LOG_DEBUG;
#if PACKET_SIZE_STATISTICS == 2
delta_stats_report();
#endif
freelog(ll, "Transmitted packets:");
freelog(ll, "%8s %8s %8s %s", "Packets", "Bytes",
"Byt/Pac", "Name");
for (i = 0; i < PACKET_LAST; i++) {
if (packets_stats[i].counter == 0) {
continue;
}
sum += packets_stats[i].size;
freelog(ll, "%8d %8d %8d %s(%i)",
packets_stats[i].counter, packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter,
get_packet_name(i),i);
}
freelog(LOG_TEST,
"turn=%d; transmitted %d bytes in %d packets;average size "
"per packet %d bytes", game.turn, sum, packet_counter,
sum / packet_counter);
freelog(LOG_TEST, "turn=%d; transmitted %d bytes", game.turn,
pc->statistics.bytes_send);
}
if (clear) {
int i;
for (i = 0; i < PACKET_LAST; i++) {
packets_stats[i].counter = 0;
packets_stats[i].size = 0;
}
packet_counter = 0;
pc->statistics.bytes_send = 0;
delta_stats_reset();
}
}
#endif
return result;
}
/**************************************************************************
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;
union {
enum packet_type type;
int itype;
} utype;
struct data_in din;
#ifdef USE_COMPRESSION
bool compressed_packet = FALSE;
int header_size = 0;
#endif
assert(sizeof(utype.type) == sizeof(utype.itype));
*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);
freelog(COMPRESS_LOG_LEVEL, "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;
freelog(COMPRESS_LOG_LEVEL, "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) {
CLOSE_FUN close_callback = close_socket_get_callback();
freelog(LOG_ERROR, "Uncompressing of the packet stream failed. "
"The connection will be closed now.");
assert(close_callback);
(*close_callback) (pc);
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;
freelog(COMPRESS_LOG_LEVEL, "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) {
CLOSE_FUN close_callback = close_socket_get_callback();
freelog(LOG_ERROR, "The packet stream is corrupt. The connection "
"will be closed now.");
assert(close_callback);
(*close_callback) (pc);
return NULL;
}
dio_get_uint8(&din, &utype.itype);
freelog(BASIC_PACKET_LOG_LEVEL, "got packet type=(%s)%d len=%d",
get_packet_name(utype.type), utype.itype, whole_packet_len);
*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;
freelog(LOG_TEST, "Received packets:");
for (i = 0; i < PACKET_LAST; i++) {
if (packets_stats[i].counter == 0)
continue;
sum += packets_stats[i].size;
freelog(LOG_TEST,
" [%-25.25s %3d]: %6d packets; %8d bytes total; "
"%5d bytes/packet average",
get_packet_name(i), i, packets_stats[i].counter,
packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter);
}
freelog(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);
}
