--- syslog-ng-3.3.1.orig/lib/nvtable.c 2011-09-30 20:01:10.000000000 +0200 +++ syslog-ng-3.3.1/lib/nvtable.c 2012-01-04 13:57:41.000000000 +0100 @@ -147,8 +148,8 @@ /* clonable LogMessage support with shared data pointers */ -#define NV_TABLE_DYNVALUE_HANDLE(x) ((x) >> 16) -#define NV_TABLE_DYNVALUE_OFS(x) ((x) & 0xFFFF) +#define NV_TABLE_DYNVALUE_HANDLE(x) ((x).handle) +#define NV_TABLE_DYNVALUE_OFS(x) ((x).ofs) static inline gchar * @@ -160,21 +161,22 @@ static inline gchar * nv_table_get_ofs_table_top(NVTable *self) { - return (gchar *) &self->data[self->num_static_entries * sizeof(self->static_entries[0]) + self->num_dyn_entries * sizeof(guint32)]; + return (gchar *) &self->data[self->num_static_entries * sizeof(self->static_entries[0]) + + self->num_dyn_entries * sizeof(NVDynValue)]; } static inline NVEntry * -nv_table_get_entry_at_ofs(NVTable *self, guint16 ofs) +nv_table_get_entry_at_ofs(NVTable *self, guint32 ofs) { if (!ofs) return NULL; return (NVEntry *) (nv_table_get_top(self) - (ofs << NV_TABLE_SCALE)); } -static inline guint32 * +static inline NVDynValue * nv_table_get_dyn_entries(NVTable *self) { - return (guint32 *) &self->static_entries[self->num_static_entries]; + return (NVDynValue *) &self->static_entries[self->num_static_entries]; } static inline gboolean @@ -211,8 +213,11 @@ gssize referenced_length; referenced_value = nv_table_get_value(self, entry->vindirect.handle, &referenced_length); - if (entry->vindirect.ofs > referenced_length) + if (entry->vindirect.ofs > referenced_length) { + if (length) + *length = 0; return null_string; + } /* here we assume that indirect references are only looked up with * non-zero terminated strings properly handled, thus the caller has @@ -228,7 +233,7 @@ if (!entry->indirect) { if (length) - *length = entry->vdirect.value_len_lo + (entry->vdirect.value_len_hi << 16); + *length = ((gssize)entry->vdirect.value_len_hi << 16) + entry->vdirect.value_len_lo; return entry->vdirect.data + entry->name_len + 1; } else @@ -236,11 +241,11 @@ } NVEntry * -nv_table_get_entry_slow(NVTable *self, NVHandle handle, guint32 **dyn_slot) +nv_table_get_entry_slow(NVTable *self, NVHandle handle, NVDynValue **dyn_slot) { - guint16 ofs; + guint32 ofs; gint l, h, m; - guint32 *dyn_entries = nv_table_get_dyn_entries(self); + NVDynValue *dyn_entries = nv_table_get_dyn_entries(self); guint32 mv; if (!self->num_dyn_entries) @@ -274,16 +279,17 @@ } } - return nv_table_get_entry_at_ofs(self, ofs); + NVEntry *entry = nv_table_get_entry_at_ofs(self, ofs); + return entry; } static gboolean -nv_table_reserve_table_entry(NVTable *self, NVHandle handle, guint32 **dyn_slot) +nv_table_reserve_table_entry(NVTable *self, NVHandle handle, NVDynValue **dyn_slot) { if (G_UNLIKELY(!(*dyn_slot) && handle > self->num_static_entries)) { /* this is a dynamic value */ - guint32 *dyn_entries = nv_table_get_dyn_entries(self);; + NVDynValue *dyn_entries = nv_table_get_dyn_entries(self);; gint l, h, m, ndx; gboolean found = FALSE; @@ -329,7 +335,8 @@ /* we set ofs to zero here, which means that the NVEntry won't be found even if the slot is present in dyn_entries */ - **dyn_slot = (handle << 16) + 0; + (**dyn_slot).handle = handle; + (**dyn_slot).ofs = 0; if (!found) self->num_dyn_entries++; } @@ -337,7 +344,7 @@ } static inline void -nv_table_set_table_entry(NVTable *self, NVHandle handle, guint16 ofs, guint32 *dyn_slot) +nv_table_set_table_entry(NVTable *self, NVHandle handle, guint32 ofs, NVDynValue *dyn_slot) { if (G_LIKELY(handle <= self->num_static_entries)) { @@ -347,7 +354,8 @@ else { /* this is a dynamic value */ - *dyn_slot = (handle << 16) + ofs; + (*dyn_slot).handle = handle; + (*dyn_slot).ofs = ofs; } } @@ -379,11 +387,11 @@ nv_table_add_value(NVTable *self, NVHandle handle, const gchar *name, gsize name_len, const gchar *value, gsize value_len, gboolean *new_entry) { NVEntry *entry; - guint16 ofs; - guint32 *dyn_slot; + guint32 ofs; + NVDynValue *dyn_slot; - if (value_len > 255 * 1024) - value_len = 255 * 1024; + if (value_len > NVTABLE_MAX_BYTES) + value_len = NVTABLE_MAX_BYTES; if (new_entry) *new_entry = FALSE; entry = nv_table_get_entry(self, handle, &dyn_slot); @@ -465,11 +473,11 @@ } gboolean -nv_table_add_value_indirect(NVTable *self, NVHandle handle, const gchar *name, gsize name_len, NVHandle ref_handle, guint8 type, guint16 rofs, guint16 rlen, gboolean *new_entry) +nv_table_add_value_indirect(NVTable *self, NVHandle handle, const gchar *name, gsize name_len, NVHandle ref_handle, guint8 type, guint32 rofs, guint32 rlen, gboolean *new_entry) { NVEntry *entry, *ref_entry; - guint32 *dyn_slot; - guint16 ofs; + NVDynValue *dyn_slot; + guint32 ofs; if (new_entry) *new_entry = FALSE; @@ -564,6 +572,7 @@ entry->name_len = 0; nv_table_set_table_entry(self, handle, ofs, dyn_slot); + return TRUE; } @@ -592,7 +601,7 @@ gboolean nv_table_foreach_entry(NVTable *self, NVTableForeachEntryFunc func, gpointer user_data) { - guint32 *dyn_entries; + NVDynValue *dyn_entries; NVEntry *entry; gint i; @@ -697,7 +706,7 @@ *new = g_malloc(new_size << NV_TABLE_SCALE); /* we only copy the header first */ - memcpy(*new, self, sizeof(NVTable) + self->num_static_entries * sizeof(self->static_entries[0]) + self->num_dyn_entries * sizeof(guint32)); + memcpy(*new, self, sizeof(NVTable) + self->num_static_entries * sizeof(self->static_entries[0]) + self->num_dyn_entries * sizeof(NVDynValue)); (*new)->ref_cnt = 1; (*new)->borrowed = FALSE; @@ -745,7 +754,7 @@ new_size = self->size + (NV_TABLE_BOUND(additional_space) >> NV_TABLE_SCALE); new = g_malloc(new_size << NV_TABLE_SCALE); - memcpy(new, self, sizeof(NVTable) + self->num_static_entries * sizeof(self->static_entries[0]) + self->num_dyn_entries * sizeof(guint32)); + memcpy(new, self, sizeof(NVTable) + self->num_static_entries * sizeof(self->static_entries[0]) + self->num_dyn_entries * sizeof(NVDynValue)); new->size = new_size; new->ref_cnt = 1; new->borrowed = FALSE; @@ -753,5 +762,6 @@ memcpy(NV_TABLE_ADDR(new, new->size - new->used), NV_TABLE_ADDR(self, self->size - self->used), self->used << NV_TABLE_SCALE); + return new; } --- syslog-ng-3.3.1.orig/lib/nvtable.h 2011-09-29 15:49:06.000000000 +0200 +++ syslog-ng-3.3.1/lib/nvtable.h 2012-01-04 09:33:45.000000000 +0100 @@ -29,12 +29,19 @@ typedef struct _NVTable NVTable; typedef struct _NVRegistry NVRegistry; +typedef struct _NVDynValue NVDynValue; typedef struct _NVEntry NVEntry; typedef guint16 NVHandle; typedef struct _NVHandleDesc NVHandleDesc; typedef gboolean (*NVTableForeachFunc)(NVHandle handle, const gchar *name, const gchar *value, gssize value_len, gpointer user_data); typedef gboolean (*NVTableForeachEntryFunc)(NVHandle handle, NVEntry *entry, gpointer user_data); +struct _NVDynValue +{ + guint16 handle; + guint32 ofs; +}; + struct _NVHandleDesc { gchar *name; @@ -90,9 +97,9 @@ } /* size related values are stored in guint16 divided by 4 */ -#define NVTABLE_MAX_BYTES (65535 * 4) /* the maximum value for the size member */ -#define NVTABLE_MAX_SIZE (65535) +#define NVTABLE_MAX_SIZE (G_MAXUINT32 >> NV_TABLE_SCALE) +#define NVTABLE_MAX_BYTES (NVTABLE_MAX_SIZE << NV_TABLE_SCALE) /* * Contains a name-value pair. @@ -102,21 +109,21 @@ /* negative offset, counting from string table top, e.g. start of the string is at @top + ofs */ guint8 indirect:1, referenced:1; guint8 name_len; - guint16 alloc_len; + guint32 alloc_len; union { struct { guint16 value_len_lo; - guint8 value_len_hi; + guint16 value_len_hi; /* variable data, first the name of this entry, then the value, both are NUL terminated */ gchar data[0]; } vdirect; struct { NVHandle handle; - guint16 ofs; - guint16 len; + guint32 ofs; + guint32 len; guint8 type; gchar name[0]; } vindirect; @@ -164,8 +171,8 @@ struct _NVTable { /* byte order indication, etc. */ - guint16 size; - guint16 used; + guint32 size; + guint32 used; guint16 num_dyn_entries; guint8 num_static_entries; guint8 ref_cnt:7, @@ -175,20 +182,20 @@ union { guint32 __dummy_for_alignment; - guint16 static_entries[0]; + guint32 static_entries[0]; gchar data[0]; }; }; #define NV_TABLE_SCALE 2 #define NV_TABLE_BOUND(x) (((x) + 0x3) & ~0x3) -#define NV_TABLE_ADDR(self, x) ((gchar *) ((self)) + ((x) << NV_TABLE_SCALE)) +#define NV_TABLE_ADDR(self, x) ((gchar *) ((self)) + ((gssize)(x) << NV_TABLE_SCALE)) #define NV_TABLE_ESTIMATE(value_num, string_sum) ((value_num) * (sizeof(guint16) + sizeof(LogMessageStringTableEntry) + string_sum) #define NV_TABLE_BOUND_NUM_STATIC(x) ((x) & ~1) gboolean nv_table_add_value(NVTable *self, NVHandle handle, const gchar *name, gsize name_len, const gchar *value, gsize value_len, gboolean *new_entry); -gboolean nv_table_add_value_indirect(NVTable *self, NVHandle handle, const gchar *name, gsize name_len, NVHandle ref_handle, guint8 type, guint16 ofs, guint16 len, gboolean *new_entry); +gboolean nv_table_add_value_indirect(NVTable *self, NVHandle handle, const gchar *name, gsize name_len, NVHandle ref_handle, guint8 type, guint32 ofs, guint32 len, gboolean *new_entry); gboolean nv_table_foreach(NVTable *self, NVRegistry *registry, NVTableForeachFunc func, gpointer user_data); gboolean nv_table_foreach_entry(NVTable *self, NVTableForeachEntryFunc func, gpointer user_data); @@ -207,7 +214,7 @@ NVTable *self G_GNUC_UNUSED = NULL; gsize size; - size = NV_TABLE_BOUND(init_length) + NV_TABLE_BOUND(sizeof(NVTable) + num_static_entries * sizeof(self->static_entries[0]) + num_dyn_values * sizeof(guint32)); + size = NV_TABLE_BOUND(init_length) + NV_TABLE_BOUND(sizeof(NVTable) + num_static_entries * sizeof(self->static_entries[0]) + num_dyn_values * sizeof(NVDynValue)); if (size < 128) return 128; if (size > NVTABLE_MAX_BYTES) @@ -222,14 +229,14 @@ } /* private declarations for inline functions */ -NVEntry *nv_table_get_entry_slow(NVTable *self, NVHandle handle, guint32 **dyn_slot); +NVEntry *nv_table_get_entry_slow(NVTable *self, NVHandle handle, NVDynValue **dyn_slot); const gchar *nv_table_resolve_indirect(NVTable *self, NVEntry *entry, gssize *len); static inline NVEntry * -__nv_table_get_entry(NVTable *self, NVHandle handle, guint16 num_static_entries, guint32 **dyn_slot) +__nv_table_get_entry(NVTable *self, NVHandle handle, guint16 num_static_entries, NVDynValue **dyn_slot) { - guint16 ofs; + guint32 ofs; if (G_UNLIKELY(!handle)) { @@ -252,7 +259,7 @@ } static inline NVEntry * -nv_table_get_entry(NVTable *self, NVHandle handle, guint32 **dyn_slot) +nv_table_get_entry(NVTable *self, NVHandle handle, NVDynValue **dyn_slot) { return __nv_table_get_entry(self, handle, self->num_static_entries, dyn_slot); } @@ -261,7 +268,7 @@ __nv_table_get_value(NVTable *self, NVHandle handle, guint16 num_static_entries, gssize *length) { NVEntry *entry; - guint32 *dyn_slot; + NVDynValue *dyn_slot; entry = nv_table_get_entry(self, handle, &dyn_slot); if (G_UNLIKELY(!entry)) @@ -274,7 +281,7 @@ if (!entry->indirect) { if (length) - *length = entry->vdirect.value_len_lo + (entry->vdirect.value_len_hi << 16); + *length = (gssize)entry->vdirect.value_len_lo + ((gssize)entry->vdirect.value_len_hi << 16); return entry->vdirect.data + entry->name_len + 1; } return nv_table_resolve_indirect(self, entry, length); --- syslog-ng-3.3.1.orig/lib/logproto.c 2011-09-23 12:09:20.000000000 +0200 +++ syslog-ng-3.3.1/lib/logproto.c 2012-01-04 11:41:06.000000000 +0100 @@ -1993,11 +1993,19 @@ if (self->frame_len > self->max_msg_size) { msg_error("Incoming frame larger than log_msg_size()", - evt_tag_int("log_msg_size", self->buffer_size - LPFS_FRAME_BUFFER), + evt_tag_int("log_msg_size", self->max_msg_size), evt_tag_int("frame_length", self->frame_len), NULL); return LPS_ERROR; } + if (self->frame_len > self->buffer_size - LPFS_FRAME_BUFFER) + { + self->buffer_size = self->frame_len + LPFS_FRAME_BUFFER; + self->buffer = g_realloc(self->buffer, self->buffer_size); + msg_debug("Resizing input buffer", + evt_tag_int("new_size", self->buffer_size), + NULL); + } if (self->buffer_pos + self->frame_len > self->buffer_size) { /* message would be too large to fit into the buffer at @@ -2066,9 +2074,8 @@ self->super.convert = (GIConv) -1; /* max message + frame header */ self->max_msg_size = max_msg_size; - self->buffer_size = max_msg_size + LPFS_FRAME_BUFFER; + self->buffer_size = 1024 + LPFS_FRAME_BUFFER; self->buffer = g_malloc(self->buffer_size); self->half_message_in_buffer = FALSE; return &self->super; } - --- syslog-ng-3.3.1.orig/tests/unit/test_nvtable.c 2010-12-31 15:13:38.000000000 +0100 +++ syslog-ng-3.3.1/tests/unit/test_nvtable.c 2011-11-11 11:21:13.000000000 +0100 @@ -365,7 +365,7 @@ /* NOTE: the sizing of the NVTable can easily be broken, it is sized to make it possible to store one direct entry */ - tab = nv_table_new(STATIC_VALUES, 0, 138); + tab = nv_table_new(STATIC_VALUES, 0, 138+3); // direct: +3 success = nv_table_add_value(tab, STATIC_HANDLE, STATIC_NAME, 4, value, 128, NULL); TEST_ASSERT(success == TRUE); @@ -437,7 +437,7 @@ /* the new entry will not fit to the space allocated to the old and neither to the NVTable */ /* setup code: add static and a dynamic-direct entry */ - tab = nv_table_new(STATIC_VALUES, 1, 154); + tab = nv_table_new(STATIC_VALUES, 1, 154+3+4); // direct: +3, indirect: +4 success = nv_table_add_value(tab, STATIC_HANDLE, STATIC_NAME, 4, value, 128, NULL); TEST_ASSERT(success == TRUE); success = nv_table_add_value(tab, handle, name, strlen(name), value, 1, NULL); @@ -535,7 +535,7 @@ /* one that is too large */ - tab = nv_table_new(STATIC_VALUES, STATIC_VALUES, 256); + tab = nv_table_new(STATIC_VALUES, 4, 256); success = nv_table_add_value(tab, STATIC_HANDLE, STATIC_NAME, 4, value, 128, NULL); TEST_ASSERT(success == TRUE); success = nv_table_add_value_indirect(tab, DYN_HANDLE, DYN_NAME, strlen(DYN_NAME), STATIC_HANDLE, 0, 1, 126, NULL); @@ -600,7 +600,7 @@ /* one that is too large */ - tab = nv_table_new(STATIC_VALUES, STATIC_VALUES, 256); + tab = nv_table_new(STATIC_VALUES, 4, 256); success = nv_table_add_value(tab, STATIC_HANDLE, STATIC_NAME, 4, value, 128, NULL); TEST_ASSERT(success == TRUE); success = nv_table_add_value_indirect(tab, DYN_HANDLE, DYN_NAME, strlen(DYN_NAME), STATIC_HANDLE, 0, 1, 126, NULL);