static gboolean
_read_header(SerializeArchive *sa, NVTable **nvtable)
{
g_assert(*nvtable == NULL);
NVTable *res = (NVTable *)g_malloc(sizeof(NVTable));
if (!serialize_read_uint32(sa, &res->size))
{
goto error;
}
if (!serialize_read_uint32(sa, &res->used))
{
goto error;
}
if (!serialize_read_uint16(sa, &res->num_dyn_entries))
{
goto error;
}
if (!serialize_read_uint8(sa, &res->num_static_entries))
{
goto error;
}
res = (NVTable *)g_realloc(res, res->size);
res->borrowed = FALSE;
res->ref_cnt = 1;
*nvtable = res;
return TRUE;
error:
if (res)
g_free(res);
return FALSE;
}
static gboolean
_deserialize_ipv4(SerializeArchive *sa, GSockAddr **addr)
{
struct sockaddr_in sin;
sin.sin_family = AF_INET;
if (!serialize_read_blob(sa, (gchar *) &sin.sin_addr, sizeof(sin.sin_addr)) ||
!serialize_read_uint16(sa, &sin.sin_port))
return FALSE;
*addr = g_sockaddr_inet_new2(&sin);
return TRUE;
}
static gboolean
_deserialize_ipv6(SerializeArchive *sa, GSockAddr **addr)
{
gboolean result = FALSE;
struct sockaddr_in6 sin6;
sin6.sin6_family = AF_INET6;
if (serialize_read_blob(sa, (gchar *) &sin6.sin6_addr, sizeof(sin6.sin6_addr)) &&
serialize_read_uint16(sa, &sin6.sin6_port))
{
*addr = g_sockaddr_inet6_new2(&sin6);
result = TRUE;
}
return result;
}
static gboolean
_read_header(SerializeArchive *sa, NVTable **nvtable)
{
NVTable *res = NULL;
guint32 size;
g_assert(*nvtable == NULL);
if (!serialize_read_uint32(sa, &size))
goto error;
if (size > NV_TABLE_MAX_BYTES)
goto error;
res = (NVTable *) g_malloc(size);
res->size = size;
if (!serialize_read_uint32(sa, &res->used))
goto error;
if (!serialize_read_uint16(sa, &res->index_size))
goto error;
if (!serialize_read_uint8(sa, &res->num_static_entries))
goto error;
/* static entries has to be known by this syslog-ng, if they are over
* LM_V_MAX, that means we have no clue how an entry is called, as static
* entries don't contain names. If there are less static entries, that
* can be ok. */
if (res->num_static_entries > LM_V_MAX)
goto error;
/* validates self->used and self->index_size value as compared to "size" */
if (!nv_table_alloc_check(res, 0))
goto error;
res->borrowed = FALSE;
res->ref_cnt = 1;
*nvtable = res;
return TRUE;
error:
if (res)
g_free(res);
return FALSE;
}
gboolean
g_sockaddr_deserialize(SerializeArchive *sa, GSockAddr **addr)
{
guint16 family;
gboolean result = TRUE;
if (!serialize_read_uint16(sa, &family))
return FALSE;
switch (family)
{
case 0:
/* special case, no address was stored */
*addr = NULL;
break;
case AF_INET:
{
result = _deserialize_ipv4(sa, addr);
break;
}
#if SYSLOG_NG_ENABLE_IPV6
case AF_INET6:
{
result = _deserialize_ipv6(sa, addr);
break;
}
#endif
case AF_UNIX:
*addr = g_sockaddr_unix_new(NULL);
break;
default:
result = FALSE;
break;
}
return result;
}
static gboolean
log_proto_buffered_server_convert_state(LogProtoBufferedServer *self, guint8 persist_version, gpointer old_state, gsize old_state_size, LogProtoBufferedServerState *state)
{
if (persist_version <= 2)
{
state->header.version = 0;
state->file_inode = 0;
state->raw_stream_pos = strtoll((gchar *) old_state, NULL, 10);
state->file_size = 0;
return TRUE;
}
else if (persist_version == 3)
{
SerializeArchive *archive;
guint32 read_length;
gint64 cur_size;
gint64 cur_inode;
gint64 cur_pos;
guint16 version;
gchar *buffer;
gsize buffer_len;
cur_inode = -1;
cur_pos = 0;
cur_size = 0;
archive = serialize_buffer_archive_new(old_state, old_state_size);
/* NOTE: the v23 conversion code adds an extra length field which we
* need to read out. */
g_assert(serialize_read_uint32(archive, &read_length) && read_length == old_state_size - sizeof(read_length));
/* original v3 format starts here */
if (!serialize_read_uint16(archive, &version) || version != 0)
{
msg_error("Internal error restoring log reader state, stored data has incorrect version",
evt_tag_int("version", version));
goto error_converting_v3;
}
if (!serialize_read_uint64(archive, (guint64 *) &cur_pos) ||
!serialize_read_uint64(archive, (guint64 *) &cur_inode) ||
!serialize_read_uint64(archive, (guint64 *) &cur_size))
{
msg_error("Internal error restoring information about the current file position, restarting from the beginning");
goto error_converting_v3;
}
if (!serialize_read_uint16(archive, &version) || version != 0)
{
msg_error("Internal error, protocol state has incorrect version",
evt_tag_int("version", version));
goto error_converting_v3;
}
if (!serialize_read_cstring(archive, &buffer, &buffer_len))
{
msg_error("Internal error, error reading buffer contents",
evt_tag_int("version", version));
goto error_converting_v3;
}
if (!self->buffer || state->buffer_size < buffer_len)
{
gsize buffer_size = MAX(self->super.options->init_buffer_size, buffer_len);
self->buffer = g_realloc(self->buffer, buffer_size);
}
serialize_archive_free(archive);
memcpy(self->buffer, buffer, buffer_len);
state->buffer_pos = 0;
state->pending_buffer_end = buffer_len;
g_free(buffer);
state->header.version = 0;
state->file_inode = cur_inode;
state->raw_stream_pos = cur_pos;
state->file_size = cur_size;
return TRUE;
error_converting_v3:
serialize_archive_free(archive);
}
return FALSE;
}
