/**************************************************************************
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);
}
/**************************************************************************
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);
}
/****************************************************************************
This method isn't endian safe and there will also be problems if
sizeof(int) at serialization time is different from sizeof(int) at
deserialization time.
****************************************************************************/
static enum attribute_serial
serialize_hash(const struct attribute_hash *hash,
void **pdata, int *pdata_length)
{
/*
* Layout of version 2:
*
* struct {
* uint32 0; always != 0 in version 1
* uint8 2;
* uint32 entries;
* uint32 total_size_in_bytes;
* } preamble;
*
* struct {
* uint32 value_size;
* char key[], char value[];
* } body[entries];
*/
const size_t entries = attribute_hash_size(hash);
int total_length, value_lengths[entries];
void *result;
struct data_out dout;
int i;
/*
* Step 1: loop through all keys and fill value_lengths and calculate
* the total_length.
*/
/* preamble */
total_length = 4 * 4;
/* body */
total_length += entries * (4 + 4 * 4); /* value_size + key */
i = 0;
attribute_hash_values_iterate(hash, pvalue) {
struct data_in din;
dio_input_init(&din, pvalue, 4);
dio_get_uint32(&din, &value_lengths[i]);
total_length += value_lengths[i];
i++;
}
attribute_hash_values_iterate_end;
/*
* Step 2: allocate memory.
*/
result = fc_malloc(total_length);
dio_output_init(&dout, result, total_length);
/*
* Step 3: fill out the preamble.
*/
dio_put_uint32(&dout, 0);
dio_put_uint8(&dout, 2);
dio_put_uint32(&dout, attribute_hash_size(hash));
dio_put_uint32(&dout, total_length);
/*
* Step 4: fill out the body.
*/
i = 0;
attribute_hash_iterate(hash, pkey, pvalue) {
dio_put_uint32(&dout, value_lengths[i]);
dio_put_uint32(&dout, pkey->key);
dio_put_uint32(&dout, pkey->id);
dio_put_sint16(&dout, pkey->x);
dio_put_sint16(&dout, pkey->y);
dio_put_memory(&dout, ADD_TO_POINTER(pvalue, 4), value_lengths[i]);
i++;
}