tvb_backing_t *backing;
tvb_comp_t *composite;
- tvb->previous = NULL;
- tvb->next = NULL;
+ tvb->previous = NULL;
+ tvb->next = NULL;
tvb->type = type;
tvb->initialized = FALSE;
tvb->length = 0;
tvbuff_t*
tvb_new(const tvbuff_type type)
{
- tvbuff_t *tvb;
+ tvbuff_t *tvb;
tvb = g_slice_new(tvbuff_t);
return tvb;
}
-static const unsigned char left_aligned_bitmask[] = {
- 0xff,
- 0x80,
- 0xc0,
- 0xe0,
- 0xf0,
- 0xf8,
- 0xfc,
- 0xfe
-};
-
-tvbuff_t *
-tvb_new_octet_aligned(tvbuff_t *tvb, guint32 bit_offset, gint32 no_of_bits)
-{
- tvbuff_t *sub_tvb = NULL;
- guint32 byte_offset;
- gint32 datalen, i;
- guint8 left, right, remaining_bits, *buf;
- const guint8 *data;
-
- byte_offset = bit_offset >> 3;
- left = bit_offset % 8; /* for left-shifting */
- right = 8 - left; /* for right-shifting */
-
- if (no_of_bits == -1) {
- datalen = tvb_length_remaining(tvb, byte_offset);
- remaining_bits = 0;
- } else {
- datalen = no_of_bits >> 3;
- remaining_bits = no_of_bits % 8;
- if (remaining_bits){
- datalen++;
- }
- }
-
- /* already aligned -> shortcut */
- if ((left == 0) && (remaining_bits == 0)) {
- return tvb_new_subset(tvb, byte_offset, datalen, -1);
- }
-
- buf = ep_alloc0(datalen);
-
- /* if at least one trailing byte is available, we must use the content
- * of that byte for the last shift (i.e. tvb_get_ptr() must use datalen + 1
- * if non extra byte is available, the last shifted byte requires
- * special treatment
- */
- if (tvb_length_remaining(tvb, byte_offset) > datalen) {
- data = tvb_get_ptr(tvb, byte_offset, datalen + 1);
- /* shift tvb data bit_offset bits to the left */
- for (i = 0; i < datalen; i++)
- buf[i] = (data[i] << left) | (data[i+1] >> right);
- } else {
- data = tvb_get_ptr(tvb, byte_offset, datalen);
- /* shift tvb data bit_offset bits to the left */
- for (i = 0; i < (datalen-1); i++)
- buf[i] = (data[i] << left) | (data[i+1] >> right);
- buf[datalen-1] = data[datalen-1] << left; /* set last octet */
- }
- buf[datalen-1] &= left_aligned_bitmask[remaining_bits];
-
- sub_tvb = tvb_new_child_real_data(tvb, buf, datalen, datalen);
-
- return sub_tvb;
-}
-
static tvbuff_t*
tvb_new_with_subset(const guint subset_tvb_offset, const guint subset_tvb_length)
{
tvbuff_t *tvb = tvb_new(TVBUFF_SUBSET);
+
tvb->tvbuffs.subset.offset = subset_tvb_offset;
tvb->tvbuffs.subset.length = subset_tvb_length;
DISSECTOR_ASSERT(tvb);
switch (tvb->type) {
- case TVBUFF_REAL_DATA:
- if (tvb->free_cb) {
- /*
- * XXX - do this with a union?
- */
- tvb->free_cb((gpointer)tvb->real_data);
- }
- break;
+ case TVBUFF_REAL_DATA:
+ if (tvb->free_cb) {
+ /*
+ * XXX - do this with a union?
+ */
+ tvb->free_cb((gpointer)tvb->real_data);
+ }
+ break;
- case TVBUFF_SUBSET:
- /* Nothing */
- break;
+ case TVBUFF_SUBSET:
+ /* Nothing */
+ break;
- case TVBUFF_COMPOSITE:
- composite = &tvb->tvbuffs.composite;
+ case TVBUFF_COMPOSITE:
+ composite = &tvb->tvbuffs.composite;
- g_slist_free(composite->tvbs);
+ g_slist_free(composite->tvbs);
- g_free(composite->start_offsets);
- g_free(composite->end_offsets);
- if (tvb->real_data) {
- /*
- * XXX - do this with a union?
- */
- g_free((gpointer)tvb->real_data);
- }
- break;
+ g_free(composite->start_offsets);
+ g_free(composite->end_offsets);
+ if (tvb->real_data) {
+ /*
+ * XXX - do this with a union?
+ */
+ g_free((gpointer)tvb->real_data);
+ }
+ break;
- default:
- DISSECTOR_ASSERT_NOT_REACHED();
+ default:
+ DISSECTOR_ASSERT_NOT_REACHED();
}
g_slice_free(tvbuff_t, tvb);
DISSECTOR_ASSERT((tvb->previous==NULL) && "tvb_free_chain(): tvb must be initial tvb in chain");
while (tvb) {
next_tvb=tvb->next;
- DISSECTOR_ASSERT(((next_tvb==NULL) || (tvb==next_tvb->previous)) && "tvb_free_chain(): corrupt tvb chain ?");
+ DISSECTOR_ASSERT(((next_tvb==NULL) || (tvb==next_tvb->previous)) && "tvb_free_chain(): corrupt tvb chain ?");
tvb_free_internal(tvb);
tvb = next_tvb;
}
add_to_chain(tvbuff_t *parent, tvbuff_t *child)
{
DISSECTOR_ASSERT(parent && child);
- DISSECTOR_ASSERT(!child->next && !child->previous);
+ DISSECTOR_ASSERT(!child->next && !child->previous);
child->next = parent->next;
child->previous = parent;
if (parent->next)
}
void
-tvb_set_child_real_data_tvbuff(tvbuff_t* parent, tvbuff_t* child)
+tvb_set_child_real_data_tvbuff(tvbuff_t *parent, tvbuff_t* child)
{
DISSECTOR_ASSERT(parent && child);
DISSECTOR_ASSERT(parent->initialized);
static void
tvb_set_real_data_no_exceptions(tvbuff_t* tvb, const guint8* data, const guint length, const gint reported_length)
{
- tvb->real_data = data;
- tvb->length = length;
+ tvb->real_data = data;
+ tvb->length = length;
tvb->reported_length = reported_length;
- tvb->initialized = TRUE;
+ tvb->initialized = TRUE;
}
void
tvbuff_t*
tvb_new_real_data(const guint8* data, const guint length, const gint reported_length)
{
- tvbuff_t *tvb;
+ tvbuff_t *tvb;
THROW_ON(reported_length < -1, ReportedBoundsError);
return tvb;
}
+static const unsigned char left_aligned_bitmask[] = {
+ 0xff,
+ 0x80,
+ 0xc0,
+ 0xe0,
+ 0xf0,
+ 0xf8,
+ 0xfc,
+ 0xfe
+};
+
+tvbuff_t *
+tvb_new_octet_aligned(tvbuff_t *tvb, guint32 bit_offset, gint32 no_of_bits)
+{
+ tvbuff_t *sub_tvb = NULL;
+ guint32 byte_offset;
+ gint32 datalen, i;
+ guint8 left, right, remaining_bits, *buf;
+ const guint8 *data;
+
+ byte_offset = bit_offset >> 3;
+ left = bit_offset % 8; /* for left-shifting */
+ right = 8 - left; /* for right-shifting */
+
+ if (no_of_bits == -1) {
+ datalen = tvb_length_remaining(tvb, byte_offset);
+ remaining_bits = 0;
+ } else {
+ datalen = no_of_bits >> 3;
+ remaining_bits = no_of_bits % 8;
+ if (remaining_bits) {
+ datalen++;
+ }
+ }
+
+ /* already aligned -> shortcut */
+ if ((left == 0) && (remaining_bits == 0)) {
+ return tvb_new_subset(tvb, byte_offset, datalen, -1);
+ }
+
+ buf = ep_alloc0(datalen);
+
+ /* if at least one trailing byte is available, we must use the content
+ * of that byte for the last shift (i.e. tvb_get_ptr() must use datalen + 1
+ * if non extra byte is available, the last shifted byte requires
+ * special treatment
+ */
+ if (tvb_length_remaining(tvb, byte_offset) > datalen) {
+ data = tvb_get_ptr(tvb, byte_offset, datalen + 1);
+ /* shift tvb data bit_offset bits to the left */
+ for (i = 0; i < datalen; i++)
+ buf[i] = (data[i] << left) | (data[i+1] >> right);
+ } else {
+ data = tvb_get_ptr(tvb, byte_offset, datalen);
+ /* shift tvb data bit_offset bits to the left */
+ for (i = 0; i < (datalen-1); i++)
+ buf[i] = (data[i] << left) | (data[i+1] >> right);
+ buf[datalen-1] = data[datalen-1] << left; /* set last octet */
+ }
+ buf[datalen-1] &= left_aligned_bitmask[remaining_bits];
+
+ sub_tvb = tvb_new_child_real_data(tvb, buf, datalen, datalen);
+
+ return sub_tvb;
+}
+
/* Computes the absolute offset and length based on a possibly-negative offset
* and a length that is possible -1 (which means "to the end of the data").
* Returns TRUE/FALSE indicating whether the offset is in bounds or
* that gets an exception, so the error is reported as an error in that
* protocol rather than the containing protocol. */
static gboolean
-compute_offset_length(const guint tvb_length_val, const guint tvb_reported_length_val, const gint offset, const gint length_val,
- guint *offset_ptr, guint *length_ptr, int *exception)
+compute_offset_length(const guint tvb_length_val, const guint tvb_reported_length_val,
+ const gint offset, const gint length_val,
+ guint *offset_ptr, guint *length_ptr, int *exception)
{
DISSECTOR_ASSERT(offset_ptr);
DISSECTOR_ASSERT(length_ptr);
static gboolean
-check_offset_length_no_exception(const guint tvb_length_val, const guint tvb_reported_length_val, const gint offset, gint const length_val,
- guint *offset_ptr, guint *length_ptr, int *exception)
+check_offset_length_no_exception(const guint tvb_length_val, const guint tvb_reported_length_val,
+ const gint offset, gint const length_val,
+ guint *offset_ptr, guint *length_ptr, int *exception)
{
guint end_offset;
- if (!compute_offset_length(tvb_length_val, tvb_reported_length_val, offset, length_val, offset_ptr, length_ptr, exception)) {
+ if (!compute_offset_length(tvb_length_val, tvb_reported_length_val,
+ offset, length_val, offset_ptr, length_ptr, exception)) {
return FALSE;
}
* either is out of bounds. Sets integer ptrs to the new offset
* and length. */
static void
-check_offset_length(const guint tvb_length_val, const guint tvb_reported_length_val, const gint offset, gint const length_val,
- guint *offset_ptr, guint *length_ptr)
+check_offset_length(const guint tvb_length_val, const guint tvb_reported_length_val,
+ const gint offset, gint const length_val,
+ guint *offset_ptr, guint *length_ptr)
{
int exception = 0;
- if (!check_offset_length_no_exception(tvb_length_val, tvb_reported_length_val, offset, length_val, offset_ptr, length_ptr, &exception)) {
+ if (!check_offset_length_no_exception(tvb_length_val, tvb_reported_length_val,
+ offset, length_val, offset_ptr, length_ptr, &exception)) {
DISSECTOR_ASSERT(exception > 0);
THROW(exception);
}
static void
tvb_set_subset_no_exceptions(tvbuff_t *tvb, tvbuff_t *backing, const gint reported_length)
{
- tvb->tvbuffs.subset.tvb = backing;
- tvb->length = tvb->tvbuffs.subset.length;
+ tvb->tvbuffs.subset.tvb = backing;
+ tvb->length = tvb->tvbuffs.subset.length;
if (reported_length == -1) {
- tvb->reported_length = backing->reported_length - tvb->tvbuffs.subset.offset;
+ tvb->reported_length = backing->reported_length - tvb->tvbuffs.subset.offset;
}
else {
- tvb->reported_length = reported_length;
+ tvb->reported_length = reported_length;
}
- tvb->initialized = TRUE;
+ tvb->initialized = TRUE;
add_to_chain(backing, tvb);
/* Optimization. If the backing buffer has a pointer to contiguous, real data,
void
tvb_set_subset(tvbuff_t *tvb, tvbuff_t *backing,
- const gint backing_offset, const gint backing_length, const gint reported_length)
+ const gint backing_offset, const gint backing_length, const gint reported_length)
{
DISSECTOR_ASSERT(tvb);
DISSECTOR_ASSERT(tvb->type == TVBUFF_SUBSET);
tvbuff_t*
tvb_new_subset(tvbuff_t *backing, const gint backing_offset, const gint backing_length, const gint reported_length)
{
- tvbuff_t *tvb;
- guint subset_tvb_offset;
- guint subset_tvb_length;
+ tvbuff_t *tvb;
+ guint subset_tvb_offset;
+ guint subset_tvb_length;
DISSECTOR_ASSERT(backing && backing->initialized);
THROW_ON(reported_length < -1, ReportedBoundsError);
check_offset_length(backing->length, backing->reported_length, backing_offset, backing_length,
- &subset_tvb_offset,
- &subset_tvb_length);
+ &subset_tvb_offset,
+ &subset_tvb_length);
tvb = tvb_new_with_subset(subset_tvb_offset, subset_tvb_length);
tvbuff_t*
tvb_new_subset_remaining(tvbuff_t *backing, const gint backing_offset)
{
- tvbuff_t *tvb;
- guint subset_tvb_offset;
- guint subset_tvb_length;
+ tvbuff_t *tvb;
+ guint subset_tvb_offset;
+ guint subset_tvb_length;
check_offset_length(backing->length, backing->reported_length, backing_offset, -1 /* backing_length */,
- &subset_tvb_offset,
- &subset_tvb_length);
+ &subset_tvb_offset,
+ &subset_tvb_length);
tvb = tvb_new_with_subset(subset_tvb_offset, subset_tvb_length);
void
tvb_composite_append(tvbuff_t* tvb, tvbuff_t* member)
{
- tvb_comp_t *composite;
+ tvb_comp_t *composite;
DISSECTOR_ASSERT(tvb && !tvb->initialized);
DISSECTOR_ASSERT(tvb->type == TVBUFF_COMPOSITE);
- composite = &tvb->tvbuffs.composite;
- composite->tvbs = g_slist_append( composite->tvbs, member );
+ composite = &tvb->tvbuffs.composite;
+ composite->tvbs = g_slist_append(composite->tvbs, member);
}
void
tvb_composite_prepend(tvbuff_t* tvb, tvbuff_t* member)
{
- tvb_comp_t *composite;
+ tvb_comp_t *composite;
DISSECTOR_ASSERT(tvb && !tvb->initialized);
DISSECTOR_ASSERT(tvb->type == TVBUFF_COMPOSITE);
- composite = &tvb->tvbuffs.composite;
- composite->tvbs = g_slist_prepend( composite->tvbs, member );
+ composite = &tvb->tvbuffs.composite;
+ composite->tvbs = g_slist_prepend(composite->tvbs, member);
}
void
tvb_composite_finalize(tvbuff_t* tvb)
{
- GSList *slist;
- guint num_members;
- tvbuff_t *member_tvb;
- tvb_comp_t *composite;
- int i = 0;
+ GSList *slist;
+ guint num_members;
+ tvbuff_t *member_tvb;
+ tvb_comp_t *composite;
+ int i = 0;
DISSECTOR_ASSERT(tvb && !tvb->initialized);
DISSECTOR_ASSERT(tvb->type == TVBUFF_COMPOSITE);
DISSECTOR_ASSERT(tvb->length == 0);
DISSECTOR_ASSERT(tvb->reported_length == 0);
- composite = &tvb->tvbuffs.composite;
+ composite = &tvb->tvbuffs.composite;
num_members = g_slist_length(composite->tvbs);
composite->start_offsets = g_new(guint, num_members);
composite->end_offsets[i] = tvb->length - 1;
i++;
}
- add_to_chain((tvbuff_t *)composite->tvbs->data, tvb); /* chain composite tvb to first member */
+ add_to_chain((tvbuff_t *)composite->tvbs->data, tvb); /* chain composite tvb to first member */
tvb->initialized = TRUE;
}
gint
tvb_length_remaining(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
+ guint abs_offset, abs_length;
DISSECTOR_ASSERT(tvb && tvb->initialized);
guint
tvb_ensure_length_remaining(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
- int exception;
+ guint abs_offset, abs_length;
+ int exception;
DISSECTOR_ASSERT(tvb && tvb->initialized);
gboolean
tvb_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length)
{
- guint abs_offset, abs_length;
+ guint abs_offset, abs_length;
DISSECTOR_ASSERT(tvb && tvb->initialized);
void
tvb_ensure_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length)
{
- guint abs_offset, abs_length;
+ guint abs_offset, abs_length;
DISSECTOR_ASSERT(tvb && tvb->initialized);
gboolean
tvb_offset_exists(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
+ guint abs_offset, abs_length;
DISSECTOR_ASSERT(tvb && tvb->initialized);
if (!compute_offset_length(tvb->length, tvb->reported_length, offset, -1, &abs_offset, &abs_length, NULL))
gint
tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
+ guint abs_offset, abs_length;
DISSECTOR_ASSERT(tvb && tvb->initialized);
}
/* Set the reported length of a tvbuff to a given value; used for protocols
- whose headers contain an explicit length and where the calling
- dissector's payload may include padding as well as the packet for
- this protocol.
-
- Also adjusts the data length. */
+ * whose headers contain an explicit length and where the calling
+ * dissector's payload may include padding as well as the packet for
+ * this protocol.
+ * Also adjusts the data length. */
void
tvb_set_reported_length(tvbuff_t* tvb, const guint reported_length)
{
static const guint8*
first_real_data_ptr(tvbuff_t *tvb)
{
- tvbuff_t *member;
+ tvbuff_t *member;
switch(tvb->type) {
case TVBUFF_REAL_DATA:
static guint
offset_from_real_beginning(const tvbuff_t *tvb, const guint counter)
{
- tvbuff_t *member;
+ tvbuff_t *member;
switch(tvb->type) {
case TVBUFF_REAL_DATA:
}
static const guint8*
-composite_ensure_contiguous_no_exception(tvbuff_t *tvb, const guint abs_offset,
- const guint abs_length)
+composite_ensure_contiguous_no_exception(tvbuff_t *tvb, const guint abs_offset, const guint abs_length)
{
- guint i, num_members;
- tvb_comp_t *composite;
- tvbuff_t *member_tvb = NULL;
- guint member_offset, member_length;
- GSList *slist;
+ guint i, num_members;
+ tvb_comp_t *composite;
+ tvbuff_t *member_tvb = NULL;
+ guint member_offset, member_length;
+ GSList *slist;
DISSECTOR_ASSERT(tvb->type == TVBUFF_COMPOSITE);
}
DISSECTOR_ASSERT(member_tvb);
- if (check_offset_length_no_exception(member_tvb->length, member_tvb->reported_length, abs_offset - composite->start_offsets[i],
- abs_length, &member_offset, &member_length, NULL)) {
+ if (check_offset_length_no_exception(member_tvb->length, member_tvb->reported_length,
+ abs_offset - composite->start_offsets[i],
+ abs_length, &member_offset, &member_length, NULL)) {
/*
* The range is, in fact, contiguous within member_tvb.
}
static const guint8*
-ensure_contiguous_no_exception(tvbuff_t *tvb, const gint offset, const gint length,
- int *exception)
+ensure_contiguous_no_exception(tvbuff_t *tvb, const gint offset, const gint length, int *exception)
{
- guint abs_offset, abs_length;
+ guint abs_offset, abs_length;
if (!check_offset_length_no_exception(tvb->length, tvb->reported_length, offset, length,
&abs_offset, &abs_length, exception)) {
static const guint8*
ensure_contiguous(tvbuff_t *tvb, const gint offset, const gint length)
{
- int exception;
+ int exception;
const guint8 *p;
p = ensure_contiguous_no_exception(tvb, offset, length, &exception);
static const guint8*
fast_ensure_contiguous(tvbuff_t *tvb, const gint offset, const guint length)
{
- guint end_offset;
- guint u_offset;
+ guint end_offset;
+ guint u_offset;
DISSECTOR_ASSERT(tvb && tvb->initialized);
/* We don't check for overflow in this fast path so we only handle simple types */
static const guint8*
guint8_pbrk(const guint8* haystack, size_t haystacklen, const guint8 *needles, guchar *found_needle)
{
- gchar tmp[256] = { 0 };
+ gchar tmp[256] = { 0 };
const guint8 *haystack_end;
while (*needles)
haystack_end = haystack + haystacklen;
while (haystack < haystack_end) {
if (tmp[*haystack]) {
- if(found_needle)
+ if (found_needle)
*found_needle = *haystack;
return haystack;
}
static void*
composite_memcpy(tvbuff_t *tvb, guint8* target, guint abs_offset, size_t abs_length)
{
- guint i, num_members;
- tvb_comp_t *composite;
- tvbuff_t *member_tvb = NULL;
- guint member_offset, member_length;
- gboolean retval;
- GSList *slist;
+ guint i, num_members;
+ tvb_comp_t *composite;
+ tvbuff_t *member_tvb = NULL;
+ guint member_offset, member_length;
+ gboolean retval;
+ GSList *slist;
DISSECTOR_ASSERT(tvb->type == TVBUFF_COMPOSITE);
/* Maybe the range specified by offset/length
* is contiguous inside one of the member tvbuffs */
- composite = &tvb->tvbuffs.composite;
+ composite = &tvb->tvbuffs.composite;
num_members = g_slist_length(composite->tvbs);
for (i = 0; i < num_members; i++) {
guint8
tvb_get_guint8(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint8));
return *ptr;
guint16
tvb_get_ntohs(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint16));
return pntohs(ptr);
guint32
tvb_get_ntoh24(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 3);
return pntoh24(ptr);
guint32
tvb_get_ntohl(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint32));
return pntohl(ptr);
guint64
tvb_get_ntoh40(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 5);
return pntoh40(ptr);
guint64
tvb_get_ntoh48(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 6);
return pntoh48(ptr);
guint64
tvb_get_ntoh56(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 7);
return pntoh56(ptr);
guint64
tvb_get_ntoh64(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint64));
return pntoh64(ptr);
guint16
tvb_get_letohs(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint16));
return pletohs(ptr);
guint32
tvb_get_letoh24(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 3);
return pletoh24(ptr);
guint32
tvb_get_letohl(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint32));
return pletohl(ptr);
guint64
tvb_get_letoh40(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 5);
return pletoh40(ptr);
guint64
tvb_get_letoh48(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 6);
return pletoh48(ptr);
guint64
tvb_get_letoh56(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, 7);
return pletoh56(ptr);
guint64
tvb_get_letoh64(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint64));
return pletoh64(ptr);
guint32
tvb_get_ipv4(tvbuff_t *tvb, const gint offset)
{
- const guint8* ptr;
- guint32 addr;
+ const guint8 *ptr;
+ guint32 addr;
ptr = fast_ensure_contiguous(tvb, offset, sizeof(guint32));
memcpy(&addr, ptr, sizeof addr);
void
tvb_get_ipv6(tvbuff_t *tvb, const gint offset, struct e_in6_addr *addr)
{
- const guint8* ptr;
+ const guint8 *ptr;
ptr = ensure_contiguous(tvb, offset, sizeof(*addr));
memcpy(addr, ptr, sizeof *addr);
*/
bit_offset = bit_offset & 0x7;
tot_no_bits = bit_offset+no_of_bits;
- if(tot_no_bits<=8){
+ if (tot_no_bits<=8) {
/* Read one octet, mask off bit_offset bits and left shift out the unused bits */
value = tvb_get_guint8(tvb,offset) & bit_mask8[bit_offset];
value = value >> (8-tot_no_bits);
- }else{
+ } else {
/* Read two octets, mask off bit_offset bits and left shift out the unused bits */
value = tvb_get_ntohs(tvb,offset) & bit_mask16[bit_offset];
value = value >> (16 - tot_no_bits);
{
guint8 bit_mask, bit_shift;
/* Byte align offset */
- gint offset = bit_offset >> 3;
- bit_offset = bit_offset & 0x7;
+ gint offset = bit_offset >> 3;
- bit_mask = (lsb0) ? 0xff : bit_mask8[bit_offset];
+ bit_offset = bit_offset & 0x7;
+
+ bit_mask = (lsb0) ? 0xff : bit_mask8[bit_offset];
bit_shift = (lsb0) ? bit_offset : (8 - bit_offset);
if (G_LIKELY(bit_offset != 0)) {
guint8 *
ep_tvb_get_bits(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean lsb0)
{
- gint no_of_bytes;
+ gint no_of_bytes;
guint8 *buf;
/* XXX, no_of_bits == -1 -> to end of tvb? */
}
no_of_bytes = (no_of_bits >> 3) + ((no_of_bits & 0x7) != 0); /* ceil(no_of_bits / 8.0) */
- buf = ep_alloc(no_of_bytes);
+ buf = ep_alloc(no_of_bytes);
tvb_get_bits_buf(tvb, bit_offset, no_of_bits, buf, lsb0);
return buf;
}
tvb_get_bits16(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits,const guint encoding)
{
gint offset;
- guint16 value = 0;
+ guint16 value = 0;
guint16 tempval = 0;
guint8 tot_no_bits;
* For backwards compatibility, treat all non-zero values as
* meaning "little-endian".
*/
- if(encoding){
+ if (encoding) {
DISSECTOR_ASSERT_NOT_REACHED();
/* This part is not implemented yet */
}
tot_no_bits = bit_offset+no_of_bits;
/* Read two octets and mask off bit_offset bits */
value = tvb_get_ntohs(tvb,offset) & bit_mask16[bit_offset];
- if(tot_no_bits < 16){
+ if (tot_no_bits < 16) {
/* Left shift out the unused bits */
value = value >> (16 - tot_no_bits);
- }else if(tot_no_bits > 16){
+ } else if (tot_no_bits > 16) {
/* Spans three octets, read next octet and shift as needed */
- value = value << (tot_no_bits - 16);
+ value = value << (tot_no_bits - 16);
tempval = tvb_get_guint8(tvb,offset+2);
tempval = tempval >> (24-tot_no_bits);
value = value | tempval;
tvb_get_bits32(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const guint encoding)
{
gint offset;
- guint32 value = 0;
- guint32 tempval = 0;
+ guint32 value = 0;
+ guint32 tempval = 0;
guint8 tot_no_bits;
guint8 tot_no_octets = 0;
- guint8 i = 0;
- gint8 shift = 0;
+ guint8 i = 0;
+ gint8 shift = 0;
if ((no_of_bits<=16)||(no_of_bits>32)) {
/* If bits <= 16 use tvb_get_bits8 or tvb_get_bits16 */
* For backwards compatibility, treat all non-zero values as
* meaning "little-endian".
*/
- if(encoding){
+ if (encoding) {
DISSECTOR_ASSERT_NOT_REACHED();
/* This part is not implemented yet */
}
tvb_get_bits64(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const guint encoding)
{
gint offset;
- guint64 value = 0;
+ guint64 value = 0;
guint64 tempval = 0;
guint8 tot_no_bits;
* For backwards compatibility, treat all non-zero values as
* meaning "little-endian".
*/
- if(encoding){
+ if (encoding) {
DISSECTOR_ASSERT_NOT_REACHED();
/* This part is not implemented yet */
}
tot_no_bits = bit_offset+no_of_bits;
/* Read eight octets and mask off bit_offset bits */
value = tvb_get_ntoh64(tvb,offset) & bit_mask64[bit_offset];
- if (tot_no_bits < 64){
+ if (tot_no_bits < 64) {
/* Left shift out the unused bits */
- value = value >> (64 - tot_no_bits);
- }else if (tot_no_bits > 64){
+ value = value >> (64 - tot_no_bits);
+ } else if (tot_no_bits > 64) {
/* Spans nine octets, read next octet and shift as needed */
- value = value << (tot_no_bits - 64);
+ value = value << (tot_no_bits - 64);
tempval = tvb_get_guint8(tvb,offset+8);
tempval = tempval >> (72-tot_no_bits);
- value = value | tempval;
+ value = value | tempval;
}
return value;
gint
tvb_find_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const guint8 needle)
{
- const guint8 *result;
- guint abs_offset, junk_length;
- guint tvbufflen;
- guint limit;
+ const guint8 *result;
+ guint abs_offset, junk_length;
+ guint tvbufflen;
+ guint limit;
DISSECTOR_ASSERT(tvb && tvb->initialized);
gint
tvb_pbrk_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const guint8 *needles, guchar *found_needle)
{
- const guint8 *result;
- guint abs_offset, junk_length;
- guint tvbufflen;
- guint limit;
+ const guint8 *result;
+ guint abs_offset, junk_length;
+ guint tvbufflen;
+ guint limit;
DISSECTOR_ASSERT(tvb && tvb->initialized);
guint
tvb_strsize(tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, junk_length;
- gint nul_offset;
+ guint abs_offset, junk_length;
+ gint nul_offset;
DISSECTOR_ASSERT(tvb && tvb->initialized);
guint
tvb_unicode_strsize(tvbuff_t *tvb, const gint offset)
{
- guint i = 0;
- gunichar2 uchar;
+ guint i = 0;
+ gunichar2 uchar;
DISSECTOR_ASSERT(tvb && tvb->initialized);
gint
tvb_strnlen(tvbuff_t *tvb, const gint offset, const guint maxlength)
{
- gint result_offset;
- guint abs_offset, junk_length;
+ gint result_offset;
+ guint abs_offset, junk_length;
DISSECTOR_ASSERT(tvb && tvb->initialized);
char *
tvb_fake_unicode(tvbuff_t *tvb, int offset, const int len, const gboolean little_endian)
{
- char *buffer;
- int i;
- guint16 character;
+ char *buffer;
+ int i;
+ guint16 character;
/* Make sure we have enough data before allocating the buffer,
so we don't blow up if the length is huge. */
char *
tvb_get_ephemeral_faked_unicode(tvbuff_t *tvb, int offset, const int len, const gboolean little_endian)
{
- char *buffer;
- int i;
- guint16 character;
+ char *buffer;
+ int i;
+ guint16 character;
/* Make sure we have enough data before allocating the buffer,
so we don't blow up if the length is huge. */
gchar *
tvb_format_text(tvbuff_t *tvb, const gint offset, const gint size)
{
- const guint8 *ptr;
- gint len = size;
+ const guint8 *ptr;
+ gint len = size;
- if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
- len = tvb_length_remaining(tvb, offset);
- ptr = ensure_contiguous(tvb, offset, len);
- }
+ if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
+ len = tvb_length_remaining(tvb, offset);
+ ptr = ensure_contiguous(tvb, offset, len);
+ }
- return format_text(ptr, len);
+ return format_text(ptr, len);
}
/*
gchar *
tvb_format_text_wsp(tvbuff_t *tvb, const gint offset, const gint size)
{
- const guint8 *ptr;
- gint len = size;
+ const guint8 *ptr;
+ gint len = size;
- if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
+ if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
- len = tvb_length_remaining(tvb, offset);
- ptr = ensure_contiguous(tvb, offset, len);
+ len = tvb_length_remaining(tvb, offset);
+ ptr = ensure_contiguous(tvb, offset, len);
- }
+ }
- return format_text_wsp(ptr, len);
+ return format_text_wsp(ptr, len);
}
gchar *
tvb_format_stringzpad(tvbuff_t *tvb, const gint offset, const gint size)
{
- const guint8 *ptr, *p;
- gint len = size;
- gint stringlen;
+ const guint8 *ptr, *p;
+ gint len = size;
+ gint stringlen;
- if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
+ if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
- len = tvb_length_remaining(tvb, offset);
- ptr = ensure_contiguous(tvb, offset, len);
+ len = tvb_length_remaining(tvb, offset);
+ ptr = ensure_contiguous(tvb, offset, len);
- }
+ }
- for (p = ptr, stringlen = 0; stringlen < len && *p != '\0'; p++, stringlen++)
- ;
- return format_text(ptr, stringlen);
+ for (p = ptr, stringlen = 0; stringlen < len && *p != '\0'; p++, stringlen++)
+ ;
+ return format_text(ptr, stringlen);
}
gchar *
tvb_format_stringzpad_wsp(tvbuff_t *tvb, const gint offset, const gint size)
{
- const guint8 *ptr, *p;
- gint len = size;
- gint stringlen;
+ const guint8 *ptr, *p;
+ gint len = size;
+ gint stringlen;
- if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
+ if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
- len = tvb_length_remaining(tvb, offset);
- ptr = ensure_contiguous(tvb, offset, len);
+ len = tvb_length_remaining(tvb, offset);
+ ptr = ensure_contiguous(tvb, offset, len);
- }
+ }
- for (p = ptr, stringlen = 0; stringlen < len && *p != '\0'; p++, stringlen++)
- ;
- return format_text_wsp(ptr, stringlen);
+ for (p = ptr, stringlen = 0; stringlen < len && *p != '\0'; p++, stringlen++)
+ ;
+ return format_text_wsp(ptr, stringlen);
}
tvb_get_string(tvbuff_t *tvb, const gint offset, const gint length)
{
const guint8 *ptr;
- guint8 *strbuf = NULL;
+ guint8 *strbuf = NULL;
tvb_ensure_bytes_exist(tvb, offset, length);
- ptr = ensure_contiguous(tvb, offset, length);
+ ptr = ensure_contiguous(tvb, offset, length);
strbuf = g_malloc(length + 1);
if (length != 0) {
memcpy(strbuf, ptr, length);
gchar *
tvb_get_unicode_string(tvbuff_t *tvb, const gint offset, gint length, const guint encoding)
{
- gchar *tmpbuf = NULL;
- gunichar2 uchar;
- gint i; /* Byte counter for tvbuff */
- gint tmpbuf_len;
- GString *strbuf = NULL;
+ gchar *tmpbuf = NULL;
+ gunichar2 uchar;
+ gint i; /* Byte counter for tvbuff */
+ gint tmpbuf_len;
+ GString *strbuf = NULL;
strbuf = g_string_new(NULL);
for(i = 0; i < length; i += 2) {
- if(encoding == ENC_BIG_ENDIAN)
+ if (encoding == ENC_BIG_ENDIAN)
uchar = tvb_get_ntohs(tvb, offset + i);
else
uchar = tvb_get_letohs(tvb, offset + i);
* in UTF-8 */
tmpbuf_len = g_unichar_to_utf8(uchar, NULL);
- tmpbuf = g_malloc(tmpbuf_len + 1); /* + 1 to make room for null
+ tmpbuf = g_malloc(tmpbuf_len + 1); /* + 1 to make room for null
* terminator */
g_unichar_to_utf8(uchar, tmpbuf);
*/
guint8 *
tvb_get_ephemeral_string_enc(tvbuff_t *tvb, const gint offset,
- const gint length, const gint encoding)
+ const gint length, const gint encoding)
{
const guint8 *ptr;
- guint8 *strbuf = NULL;
+ guint8 *strbuf = NULL;
tvb_ensure_bytes_exist(tvb, offset, length);
- ptr = ensure_contiguous(tvb, offset, length);
+ ptr = ensure_contiguous(tvb, offset, length);
strbuf = ep_alloc(length + 1);
if (length != 0) {
memcpy(strbuf, ptr, length);
}
guint8 *
-tvb_get_ephemeral_string(tvbuff_t *tvb, const gint offset,
- const gint length)
+tvb_get_ephemeral_string(tvbuff_t *tvb, const gint offset, const gint length)
{
return tvb_get_ephemeral_string_enc(tvb, offset, length, ENC_UTF_8|ENC_NA);
}
gchar *
tvb_get_ephemeral_unicode_string(tvbuff_t *tvb, const gint offset, gint length, const guint encoding)
{
- gchar *tmpbuf = NULL;
- gunichar2 uchar;
- gint i; /* Byte counter for tvbuff */
- gint tmpbuf_len;
+ gchar *tmpbuf = NULL;
+ gunichar2 uchar;
+ gint i; /* Byte counter for tvbuff */
+ gint tmpbuf_len;
emem_strbuf_t *strbuf = NULL;
strbuf = ep_strbuf_new(NULL);
for(i = 0; i < length; i += 2) {
- if(encoding == ENC_BIG_ENDIAN)
+ if (encoding == ENC_BIG_ENDIAN)
uchar = tvb_get_ntohs(tvb, offset + i);
else
uchar = tvb_get_letohs(tvb, offset + i);
* in UTF-8 */
tmpbuf_len = g_unichar_to_utf8(uchar, NULL);
- tmpbuf = g_malloc(tmpbuf_len + 1); /* + 1 to make room for null
+ tmpbuf = g_malloc(tmpbuf_len + 1); /* + 1 to make room for null
* terminator */
g_unichar_to_utf8(uchar, tmpbuf);
tvb_get_seasonal_string(tvbuff_t *tvb, const gint offset, const gint length)
{
const guint8 *ptr;
- guint8 *strbuf = NULL;
+ guint8 *strbuf = NULL;
tvb_ensure_bytes_exist(tvb, offset, length);
- ptr = ensure_contiguous(tvb, offset, length);
+ ptr = ensure_contiguous(tvb, offset, length);
strbuf = se_alloc(length + 1);
if (length != 0) {
memcpy(strbuf, ptr, length);
guint8 *
tvb_get_stringz_enc(tvbuff_t *tvb, const gint offset, gint *lengthp, gint encoding)
{
- guint size;
+ guint size;
guint8 *strptr;
- size = tvb_strsize(tvb, offset);
+ size = tvb_strsize(tvb, offset);
strptr = g_malloc(size);
tvb_memcpy(tvb, strptr, offset, size);
if ((encoding & ENC_CHARENCODING_MASK) == ENC_EBCDIC)
const guint8 *
tvb_get_const_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
{
- guint size;
+ guint size;
const guint8 *strptr;
- size = tvb_strsize(tvb, offset);
+ size = tvb_strsize(tvb, offset);
strptr = ensure_contiguous(tvb, offset, size);
if (lengthp)
*lengthp = size;
guint8 *
tvb_get_ephemeral_stringz_enc(tvbuff_t *tvb, const gint offset, gint *lengthp, gint encoding)
{
- guint size;
+ guint size;
guint8 *strptr;
- size = tvb_strsize(tvb, offset);
+ size = tvb_strsize(tvb, offset);
strptr = ep_alloc(size);
tvb_memcpy(tvb, strptr, offset, size);
if ((encoding & ENC_CHARENCODING_MASK) == ENC_EBCDIC)
gchar *
tvb_get_ephemeral_unicode_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp, const guint encoding)
{
- gchar *tmpbuf = NULL;
- gunichar2 uchar;
- gint size; /* Number of UTF-16 characters */
- gint i; /* Byte counter for tvbuff */
- gint tmpbuf_len;
+ gchar *tmpbuf = NULL;
+ gunichar2 uchar;
+ gint size; /* Number of UTF-16 characters */
+ gint i; /* Byte counter for tvbuff */
+ gint tmpbuf_len;
emem_strbuf_t *strbuf = NULL;
strbuf = ep_strbuf_new(NULL);
for(i = 0; i < size; i += 2) {
- if(encoding == ENC_BIG_ENDIAN)
+ if (encoding == ENC_BIG_ENDIAN)
uchar = tvb_get_ntohs(tvb, offset + i);
else
uchar = tvb_get_letohs(tvb, offset + i);
g_free(tmpbuf);
}
- if(lengthp)
+ if (lengthp)
*lengthp = i; /* Number of *bytes* processed */
return strbuf->str;
guint8 *
tvb_get_seasonal_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
{
- guint size;
+ guint size;
guint8 *strptr;
- size = tvb_strsize(tvb, offset);
+ size = tvb_strsize(tvb, offset);
strptr = se_alloc(size);
tvb_memcpy(tvb, strptr, offset, size);
if (lengthp)
* including the terminating-NUL.
*/
static gint
-_tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer,
- gint *bytes_copied)
+_tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer, gint *bytes_copied)
{
- gint stringlen;
- guint abs_offset, junk_length;
- gint limit, len;
+ gint stringlen;
+ guint abs_offset, junk_length;
+ gint limit, len;
gboolean decreased_max = FALSE;
check_offset_length(tvb->length, tvb->reported_length, offset, 0, &abs_offset, &junk_length);
* terminator. (It's not set if we return -1.)
*/
gint
-tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len, gint *next_offset,
- const gboolean desegment)
+tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len, gint *next_offset, const gboolean desegment)
{
- gint eob_offset;
- gint eol_offset;
- int linelen;
+ gint eob_offset;
+ gint eol_offset;
+ int linelen;
guchar found_needle = 0;
if (len == -1)
* terminator.
*/
gint
-tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len,
- gint *next_offset)
+tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len, gint *next_offset)
{
- gint cur_offset, char_offset;
+ gint cur_offset, char_offset;
gboolean is_quoted;
- guchar c = 0;
- gint eob_offset;
- int linelen;
+ guchar c = 0;
+ gint eob_offset;
+ int linelen;
if (len == -1)
len = tvb_length_remaining(tvb, offset);
eob_offset = offset + len;
cur_offset = offset;
- is_quoted = FALSE;
+ is_quoted = FALSE;
for (;;) {
/*
* Is this part of the string quoted?
* character following offset or offset + maxlength -1 whichever
* is smaller.
*/
-gint tvb_skip_wsp(tvbuff_t* tvb, const gint offset, const gint maxlength)
+gint
+tvb_skip_wsp(tvbuff_t* tvb, const gint offset, const gint maxlength)
{
- gint counter = offset;
- gint end, tvb_len;
+ gint counter = offset;
+ gint end, tvb_len;
guint8 tempchar;
/* Get the length remaining */
tvb_len = tvb_length(tvb);
- end = offset + maxlength;
+ end = offset + maxlength;
if (end >= tvb_len)
{
end = tvb_len;
return (counter);
}
-gint tvb_skip_wsp_return(tvbuff_t* tvb, const gint offset){
- gint counter = offset;
- gint end;
+gint
+tvb_skip_wsp_return(tvbuff_t* tvb, const gint offset) {
+ gint counter = offset;
+ gint end;
guint8 tempchar;
- end = 0;
+ end = 0;
for(counter = offset; counter > end &&
((tempchar = tvb_get_guint8(tvb,counter)) == ' ' ||
* Note a tvbuff content of 0xf is considered a 'filler' and will end the conversion.
*/
static dgt_set_t Dgt1_9_bcd = {
- {
- /* 0 1 2 3 4 5 6 7 8 9 a b c d e */
- '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?'
- }
+ {
+ /* 0 1 2 3 4 5 6 7 8 9 a b c d e */
+ '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?'
+ }
};
const gchar *
tvb_bcd_dig_to_ep_str(tvbuff_t *tvb, const gint offset, const gint len, dgt_set_t *dgt, gboolean skip_first)
{
- int length;
- guint8 octet;
- int i=0;
- char *digit_str;
- gint t_offset = offset;
+ int length;
+ guint8 octet;
+ int i = 0;
+ char *digit_str;
+ gint t_offset = offset;
if (!dgt)
dgt = &Dgt1_9_bcd;
- if( len == -1){
+ if (len == -1) {
length = tvb_length(tvb);
- if (length < offset){
+ if (length < offset) {
return "";
}
- }else{
+ } else {
length = offset + len;
}
digit_str = ep_alloc((length - offset)*2+1);
- while ( t_offset < length ){
+ while (t_offset < length) {
octet = tvb_get_guint8(tvb,t_offset);
- if (!skip_first){
+ if (!skip_first) {
digit_str[i] = dgt->out[octet & 0x0f];
i++;
}
gint
tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, const gint haystack_offset)
{
- guint haystack_abs_offset, haystack_abs_length;
- const guint8 *haystack_data;
- const guint8 *needle_data;
- const guint needle_len = needle_tvb->length;
- const guint8 *location;
+ guint haystack_abs_offset, haystack_abs_length;
+ const guint8 *haystack_data;
+ const guint8 *needle_data;
+ const guint needle_len = needle_tvb->length;
+ const guint8 *location;
DISSECTOR_ASSERT(haystack_tvb && haystack_tvb->initialized);
/* Get pointers to the tvbuffs' data. */
haystack_data = ensure_contiguous(haystack_tvb, 0, -1);
- needle_data = ensure_contiguous(needle_tvb, 0, -1);
+ needle_data = ensure_contiguous(needle_tvb, 0, -1);
check_offset_length(haystack_tvb->length, haystack_tvb->reported_length, haystack_offset, -1,
&haystack_abs_offset, &haystack_abs_length);
tvbuff_t *
tvb_uncompress(tvbuff_t *tvb, const int offset, int comprlen)
{
- gint err = Z_OK;
- guint bytes_out = 0;
- guint8 *compr = NULL;
- guint8 *uncompr = NULL;
- tvbuff_t *uncompr_tvb = NULL;
- z_streamp strm = NULL;
- Bytef *strmbuf = NULL;
- guint inits_done = 0;
- gint wbits = MAX_WBITS;
- guint8 *next = NULL;
- guint bufsiz = TVB_Z_MIN_BUFSIZ;
+ gint err = Z_OK;
+ guint bytes_out = 0;
+ guint8 *compr = NULL;
+ guint8 *uncompr = NULL;
+ tvbuff_t *uncompr_tvb = NULL;
+ z_streamp strm = NULL;
+ Bytef *strmbuf = NULL;
+ guint inits_done = 0;
+ gint wbits = MAX_WBITS;
+ guint8 *next = NULL;
+ guint bufsiz = TVB_Z_MIN_BUFSIZ;
#ifdef TVB_Z_DEBUG
- guint inflate_passes = 0;
- guint bytes_in = tvb_length_remaining(tvb, offset);
+ guint inflate_passes = 0;
+ guint bytes_in = tvb_length_remaining(tvb, offset);
#endif
if (tvb == NULL) {
next = compr;
- strm = g_new0(z_stream, 1);
- strm->next_in = next;
- strm->avail_in = comprlen;
+ strm = g_new0(z_stream, 1);
+ strm->next_in = next;
+ strm->avail_in = comprlen;
- strmbuf = g_malloc0(bufsiz);
- strm->next_out = strmbuf;
+ strmbuf = g_malloc0(bufsiz);
+ strm->next_out = strmbuf;
strm->avail_out = bufsiz;
err = inflateInit2(strm, wbits);
while (1) {
memset(strmbuf, '\0', bufsiz);
- strm->next_out = strmbuf;
+ strm->next_out = strmbuf;
strm->avail_out = bufsiz;
err = inflate(strm, Z_SYNC_FLUSH);
bytes_out += bytes_pass;
- if ( err == Z_STREAM_END) {
+ if (err == Z_STREAM_END) {
inflateEnd(strm);
g_free(strm);
g_free(strmbuf);
* fix to make it work (setting windowBits to 31)
* doesn't work with all versions of the library.
*/
- Bytef *c = compr + 2;
- Bytef flags = 0;
+ Bytef *c = compr + 2;
+ Bytef flags = 0;
if (*c == Z_DEFLATED) {
c++;
inflateReset(strm);
- strm->next_in = next;
- strm->avail_in = comprlen;
+ strm->next_in = next;
+ strm->avail_in = comprlen;
inflateEnd(strm);
memset(strmbuf, '\0', bufsiz);
- strm->next_out = strmbuf;
+ strm->next_out = strmbuf;
strm->avail_out = bufsiz;
err = inflateInit2(strm, wbits);
#endif
if (uncompr != NULL) {
- uncompr_tvb = tvb_new_real_data((guint8*) uncompr, bytes_out,
- bytes_out);
+ uncompr_tvb = tvb_new_real_data((guint8*) uncompr, bytes_out, bytes_out);
tvb_set_free_cb(uncompr_tvb, g_free);
}
g_free(compr);
git.samba.org / obnox / wireshark / wip.git / commitdiff