/**************************************************************************
It returns the request id of the outgoing packet (or 0 if is_server()).
**************************************************************************/
int send_packet_data(struct connection *pc, unsigned char *data, int len)
{
/* default for the server */
int result = 0;
log_packet("sending packet type=%s(%d) len=%d to %s",
packet_name(data[2]), data[2], len,
is_server() ? pc->username : "******");
if (!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;
log_packet("sending request %d", result);
}
if (pc->outgoing_packet_notify) {
pc->outgoing_packet_notify(pc, data[2], len, result);
}
#ifdef USE_COMPRESSION
if (TRUE) {
int packet_type;
int size = len;
packet_type = data[2];
if (conn_compression_frozen(pc)) {
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);
log_compress2("COMPRESS: putting %s into the queue",
packet_name(packet_type));
if (MAX_LEN_BUFFER < byte_vector_size(&pc->compression.queue)) {
log_compress2("COMPRESS: huge queue, forcing to flush (%lu/%lu)",
(long unsigned)
byte_vector_size(&pc->compression.queue),
(long unsigned) MAX_LEN_BUFFER);
if (!conn_compression_flush(pc)) {
return -1;
}
byte_vector_reserve(&pc->compression.queue, 0);
}
} else {
stat_size_alone += size;
log_compress("COMPRESS: sending %s alone (%d bytes total)",
packet_name(packet_type), stat_size_alone);
connection_send_data(pc, data, len);
}
log_compress2("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
connection_send_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;
#define log_ll log_debug
#if PACKET_SIZE_STATISTICS == 2
delta_stats_report();
#endif
log_ll("Transmitted packets:");
log_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;
log_ll("%8d %8d %8d %s(%i)",
packets_stats[i].counter, packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter,
packet_name(i),i);
}
log_test("turn=%d; transmitted %d bytes in %d packets;average size "
"per packet %d bytes", game.turn, sum, packet_counter,
sum / packet_counter);
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();
}
}
#undef log_ll
#endif /* PACKET_SIZE_STATISTICS */
return result;
}
/**************************************************************************
It returns the request id of the outgoing packet (or 0 if is_server()).
**************************************************************************/
int send_packet_data(struct connection *pc, unsigned char *data, int len,
enum packet_type packet_type)
{
/* default for the server */
int result = 0;
log_packet("sending packet type=%s(%d) len=%d to %s",
packet_name(packet_type), packet_type, len,
is_server() ? pc->username : "******");
if (!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;
log_packet("sending request %d", result);
}
if (pc->outgoing_packet_notify) {
pc->outgoing_packet_notify(pc, packet_type, len, result);
}
#ifdef USE_COMPRESSION
if (TRUE) {
int size = len;
if (conn_compression_frozen(pc)) {
size_t old_size;
/* Keep this a decent amount less than MAX_LEN_BUFFER to avoid the
* (remote) possibility of trying to dump MAX_LEN_BUFFER to the
* network in one go */
#define MAX_LEN_COMPRESS_QUEUE (MAX_LEN_BUFFER/2)
FC_STATIC_ASSERT(MAX_LEN_COMPRESS_QUEUE < MAX_LEN_BUFFER,
compress_queue_maxlen_too_big);
/* If this packet would cause us to overfill the queue, flush
* everything that's in there already before queuing this one */
if (MAX_LEN_COMPRESS_QUEUE
< byte_vector_size(&pc->compression.queue) + len) {
log_compress2("COMPRESS: huge queue, forcing to flush (%lu/%lu)",
(long unsigned)
byte_vector_size(&pc->compression.queue),
(long unsigned) MAX_LEN_COMPRESS_QUEUE);
if (!conn_compression_flush(pc)) {
return -1;
}
byte_vector_reserve(&pc->compression.queue, 0);
}
old_size = byte_vector_size(&pc->compression.queue);
byte_vector_reserve(&pc->compression.queue, old_size + len);
memcpy(pc->compression.queue.p + old_size, data, len);
log_compress2("COMPRESS: putting %s into the queue",
packet_name(packet_type));
} else {
stat_size_alone += size;
log_compress("COMPRESS: sending %s alone (%d bytes total)",
packet_name(packet_type), stat_size_alone);
connection_send_data(pc, data, len);
}
log_compress2("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 /* USE_COMPRESSION */
connection_send_data(pc, data, len);
#endif /* USE_COMPRESSION */
#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 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;
#define log_ll log_debug
#if PACKET_SIZE_STATISTICS == 2
delta_stats_report();
#endif
log_ll("Transmitted packets:");
log_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;
log_ll("%8d %8d %8d %s(%i)",
packets_stats[i].counter, packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter,
packet_name(i),i);
}
log_test("turn=%d; transmitted %d bytes in %d packets;average size "
"per packet %d bytes", game.turn, sum, packet_counter,
sum / packet_counter);
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();
}
}
#undef log_ll
#endif /* PACKET_SIZE_STATISTICS */
return result;
}
