/**************************************************************************
Remove the packet from the buffer
**************************************************************************/
void remove_packet_from_buffer(struct socket_packet_buffer *buffer)
{
struct data_in din;
int len;
dio_input_init(&din, buffer->data, buffer->ndata);
dio_get_uint16(&din, &len);
memmove(buffer->data, buffer->data + len, buffer->ndata - len);
buffer->ndata -= len;
log_debug("remove_packet_from_buffer: remove %d; remaining %d",
len, buffer->ndata);
}
/**************************************************************************
Sanity check packet
**************************************************************************/
void check_packet(struct data_in *din, struct connection *pc)
{
size_t rem = dio_input_remaining(din);
if (din->bad_string || din->bad_bit_string || rem != 0) {
char from[MAX_LEN_ADDR + MAX_LEN_NAME + 128];
int type, len;
fc_assert_ret(pc != NULL);
fc_snprintf(from, sizeof(from), " from %s", conn_description(pc));
dio_input_rewind(din);
dio_get_uint16(din, &len);
dio_get_uint16(din, &type);
if (din->bad_string) {
log_error("received bad string in packet (type %d, len %d)%s",
type, len, from);
}
if (din->bad_bit_string) {
log_error("received bad bit string in packet (type %d, len %d)%s",
type, len, from);
}
if (din->too_short) {
log_error("received short packet (type %d, len %d)%s",
type, len, from);
}
if (rem > 0) {
/* This may be ok, eg a packet from a newer version with extra info
* which we should just ignore */
log_verbose("received long packet (type %d, len %d, rem %lu)%s", type,
len, (unsigned long)rem, from);
}
}
}
/**************************************************************************
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);
}
