/**************************************************************************
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;
}
/**************************************************************************
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;
}
