* Testy, Virtual(-izable) Buffer of guint8*'s
*
* "Testy" -- the buffer gets mad when an attempt to access data
- * beyond the bounds of the buffer. An exception is thrown.
+ * beyond the bounds of the buffer. An exception is thrown.
*
* "Virtual" -- the buffer can have its own data, can use a subset of
- * the data of a backing tvbuff, or can be a composite of
- * other tvbuffs.
+ * the data of a backing tvbuff, or can be a composite of
+ * other tvbuffs.
*
* $Id$
*
static const guint8*
ensure_contiguous(tvbuff_t *tvb, gint offset, gint length);
+#if GLIB_CHECK_VERSION(2,10,0)
+#else
/* We dole out tvbuff's from this memchunk. */
static GMemChunk *tvbuff_mem_chunk = NULL;
+#endif
void
tvbuff_init(void)
{
+#if GLIB_CHECK_VERSION(2,10,0)
+#else
if (!tvbuff_mem_chunk)
tvbuff_mem_chunk = g_mem_chunk_create(tvbuff_t, 20, G_ALLOC_AND_FREE);
+#endif
}
void
tvbuff_cleanup(void)
{
+#if GLIB_CHECK_VERSION(2,10,0)
+#else
if (tvbuff_mem_chunk)
g_mem_chunk_destroy(tvbuff_mem_chunk);
tvbuff_mem_chunk = NULL;
+#endif
}
static void
{
tvbuff_t *tvb;
+#if GLIB_CHECK_VERSION(2,10,0)
+ tvb = g_slice_new(tvbuff_t);
+#else
tvb = g_chunk_new(tvbuff_t, tvbuff_mem_chunk);
+#endif
tvb_init(tvb, type);
return tvb;
}
+static tvbuff_t*
+tvb_new_with_subset(guint subset_tvb_offset, 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;
+
+ return tvb;
+}
+
void
tvb_free(tvbuff_t* tvb)
{
g_slist_free(tvb->used_in);
}
+#if GLIB_CHECK_VERSION(2,10,0)
+ g_slice_free(tvbuff_t, tvb);
+#else
g_chunk_free(tvb, tvbuff_mem_chunk);
+#endif
}
}
add_to_used_in_list(parent, child);
}
+static void
+tvb_set_real_data_no_exceptions(tvbuff_t* tvb, const guint8* data, guint length, gint reported_length)
+{
+ tvb->real_data = data;
+ tvb->length = length;
+ tvb->reported_length = reported_length;
+ tvb->initialized = TRUE;
+}
+
void
tvb_set_real_data(tvbuff_t* tvb, const guint8* data, guint length, gint reported_length)
{
DISSECTOR_ASSERT(tvb->type == TVBUFF_REAL_DATA);
DISSECTOR_ASSERT(!tvb->initialized);
- if (reported_length < -1) {
- THROW(ReportedBoundsError);
- }
+ THROW_ON(reported_length < -1, ReportedBoundsError);
- tvb->real_data = data;
- tvb->length = length;
- tvb->reported_length = reported_length;
- tvb->initialized = TRUE;
+ tvb_set_real_data_no_exceptions(tvb, data, length, reported_length);
}
tvbuff_t*
tvb_new_real_data(const guint8* data, guint length, gint reported_length)
{
- static tvbuff_t *last_tvb=NULL;
tvbuff_t *tvb;
- tvb = tvb_new(TVBUFF_REAL_DATA);
+ THROW_ON(reported_length < -1, ReportedBoundsError);
- if(last_tvb){
- tvb_free(last_tvb);
- }
- /* remember this tvb in case we throw an exception and
- * lose the pointer to it.
- */
- last_tvb=tvb;
+ tvb = tvb_new(TVBUFF_REAL_DATA);
- tvb_set_real_data(tvb, data, length, reported_length);
+ tvb_set_real_data_no_exceptions(tvb, data, length, reported_length);
/*
* This is the top-level real tvbuff for this data source,
*/
tvb->ds_tvb = tvb;
- /* ok no exception so we dont need to remember it any longer */
- last_tvb=NULL;
-
return tvb;
}
if (tvb) {
tvb_set_child_real_data_tvbuff (parent, tvb);
}
-
+
return tvb;
}
* 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(tvbuff_t *tvb, gint offset, gint length,
+compute_offset_length(guint tvb_length, guint tvb_reported_length, gint offset, gint length,
guint *offset_ptr, guint *length_ptr, int *exception)
{
DISSECTOR_ASSERT(offset_ptr);
/* Compute the offset */
if (offset >= 0) {
/* Positive offset - relative to the beginning of the packet. */
- if ((guint) offset > tvb->reported_length) {
+ if ((guint) offset > tvb_reported_length) {
if (exception) {
*exception = ReportedBoundsError;
}
return FALSE;
}
- else if ((guint) offset > tvb->length) {
+ else if ((guint) offset > tvb_length) {
if (exception) {
*exception = BoundsError;
}
}
else {
/* Negative offset - relative to the end of the packet. */
- if ((guint) -offset > tvb->reported_length) {
+ if ((guint) -offset > tvb_reported_length) {
if (exception) {
*exception = ReportedBoundsError;
}
return FALSE;
}
- else if ((guint) -offset > tvb->length) {
+ else if ((guint) -offset > tvb_length) {
if (exception) {
*exception = BoundsError;
}
return FALSE;
}
else {
- *offset_ptr = tvb->length + offset;
+ *offset_ptr = tvb_length + offset;
}
}
return FALSE;
}
else if (length == -1) {
- *length_ptr = tvb->length - *offset_ptr;
+ *length_ptr = tvb_length - *offset_ptr;
}
else {
*length_ptr = length;
static gboolean
-check_offset_length_no_exception(tvbuff_t *tvb, gint offset, gint length,
+check_offset_length_no_exception(guint tvb_length, guint tvb_reported_length, gint offset, gint length,
guint *offset_ptr, guint *length_ptr, int *exception)
{
guint end_offset;
- DISSECTOR_ASSERT(tvb && tvb->initialized);
-
- if (!compute_offset_length(tvb, offset, length, offset_ptr, length_ptr, exception)) {
+ if (!compute_offset_length(tvb_length, tvb_reported_length, offset, length, offset_ptr, length_ptr, exception)) {
return FALSE;
}
* If not, return TRUE; otherwise, return FALSE and, if "exception"
* is non-null, return the appropriate exception through it.
*/
- if (end_offset <= tvb->length) {
+ if (end_offset <= tvb_length) {
return TRUE;
}
- else if (end_offset <= tvb->reported_length) {
+ else if (end_offset <= tvb_reported_length) {
if (exception) {
*exception = BoundsError;
}
* either is out of bounds. Sets integer ptrs to the new offset
* and length. */
static void
-check_offset_length(tvbuff_t *tvb, gint offset, gint length,
+check_offset_length(guint tvb_length, guint tvb_reported_length, gint offset, gint length,
guint *offset_ptr, guint *length_ptr)
{
int exception = 0;
- if (!check_offset_length_no_exception(tvb, offset, length, offset_ptr, length_ptr, &exception)) {
+ if (!check_offset_length_no_exception(tvb_length, tvb_reported_length, offset, length, offset_ptr, length_ptr, &exception)) {
DISSECTOR_ASSERT(exception > 0);
THROW(exception);
}
- return;
}
-
-void
-tvb_set_subset(tvbuff_t *tvb, tvbuff_t *backing,
- gint backing_offset, gint backing_length, gint reported_length)
+static void
+tvb_set_subset_no_exceptions(tvbuff_t *tvb, tvbuff_t *backing, gint reported_length)
{
- DISSECTOR_ASSERT(tvb);
- DISSECTOR_ASSERT(tvb->type == TVBUFF_SUBSET);
- DISSECTOR_ASSERT(!tvb->initialized);
-
- if (reported_length < -1) {
- THROW(ReportedBoundsError);
- }
-
- check_offset_length(backing, backing_offset, backing_length,
- &tvb->tvbuffs.subset.offset,
- &tvb->tvbuffs.subset.length);
-
tvb->tvbuffs.subset.tvb = backing;
tvb->length = tvb->tvbuffs.subset.length;
}
}
+void
+tvb_set_subset(tvbuff_t *tvb, tvbuff_t *backing,
+ gint backing_offset, gint backing_length, gint reported_length)
+{
+ DISSECTOR_ASSERT(tvb);
+ DISSECTOR_ASSERT(tvb->type == TVBUFF_SUBSET);
+ DISSECTOR_ASSERT(!tvb->initialized);
+
+ THROW_ON(reported_length < -1, ReportedBoundsError);
+
+ check_offset_length(backing->length, backing->reported_length, backing_offset, backing_length,
+ &tvb->tvbuffs.subset.offset,
+ &tvb->tvbuffs.subset.length);
+
+ tvb_set_subset_no_exceptions(tvb, backing, reported_length);
+}
tvbuff_t*
tvb_new_subset(tvbuff_t *backing, gint backing_offset, gint backing_length, gint reported_length)
{
- static tvbuff_t *last_tvb=NULL;
tvbuff_t *tvb;
+ guint subset_tvb_offset;
+ guint subset_tvb_length;
- tvb = tvb_new(TVBUFF_SUBSET);
+ DISSECTOR_ASSERT(backing && backing->initialized);
- if(last_tvb){
- tvb_free(last_tvb);
- }
- /* remember this tvb in case we throw an exception and
- * lose the pointer to it.
- */
- last_tvb=tvb;
+ THROW_ON(reported_length < -1, ReportedBoundsError);
+
+ check_offset_length(backing->length, backing->reported_length, backing_offset, backing_length,
+ &subset_tvb_offset,
+ &subset_tvb_length);
+
+ tvb = tvb_new_with_subset(subset_tvb_offset, subset_tvb_length);
- tvb_set_subset(tvb, backing, backing_offset, backing_length, reported_length);
+ tvb_set_subset_no_exceptions(tvb, backing, reported_length);
/*
* The top-level data source of this tvbuff is the top-level
*/
tvb->ds_tvb = backing->ds_tvb;
- /* ok no exception so we dont need to remember it any longer */
- last_tvb=NULL;
+ return tvb;
+}
+
+tvbuff_t*
+tvb_new_subset_remaining(tvbuff_t *backing, gint backing_offset)
+{
+ 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);
+
+ tvb = tvb_new_with_subset(subset_tvb_offset, subset_tvb_length);
+
+ tvb_set_subset_no_exceptions(tvb, backing, -1 /* reported_length */);
+
+ /*
+ * The top-level data source of this tvbuff is the top-level
+ * data source of its parent.
+ */
+ tvb->ds_tvb = backing->ds_tvb;
return tvb;
}
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL)) {
+ if (compute_offset_length(tvb->length, tvb->reported_length, offset, -1, &abs_offset, &abs_length, NULL)) {
return abs_length;
}
else {
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (!compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, &exception)) {
+ if (!compute_offset_length(tvb->length, tvb->reported_length, offset, -1, &abs_offset, &abs_length, &exception)) {
THROW(exception);
}
if (abs_length == 0) {
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (!compute_offset_length(tvb, offset, length, &abs_offset, &abs_length, NULL))
+ if (!compute_offset_length(tvb->length, tvb->reported_length, offset, length, &abs_offset, &abs_length, NULL))
return FALSE;
if (abs_offset + abs_length <= tvb->length) {
if (length < 0) {
THROW(ReportedBoundsError);
}
- check_offset_length(tvb, offset, length, &abs_offset, &abs_length);
+ check_offset_length(tvb->length, tvb->reported_length, offset, length, &abs_offset, &abs_length);
}
gboolean
guint abs_offset, abs_length;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (!compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL))
+ if (!compute_offset_length(tvb->length, tvb->reported_length, offset, -1, &abs_offset, &abs_length, NULL))
return FALSE;
if (abs_offset < tvb->length) {
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL)) {
+ if (compute_offset_length(tvb->length, tvb->reported_length, offset, -1, &abs_offset, &abs_length, NULL)) {
if (tvb->reported_length >= abs_offset)
return tvb->reported_length - abs_offset;
else
}
#endif
-int
-offset_from_real_beginning(tvbuff_t *tvb, int counter)
+static guint
+offset_from_real_beginning(tvbuff_t *tvb, guint counter)
{
tvbuff_t *member;
return 0;
}
+guint
+tvb_offset_from_real_beginning(tvbuff_t *tvb)
+{
+ return offset_from_real_beginning(tvb, 0);
+}
+
static const guint8*
composite_ensure_contiguous_no_exception(tvbuff_t *tvb, guint abs_offset,
guint abs_length)
}
DISSECTOR_ASSERT(member_tvb);
- if (check_offset_length_no_exception(member_tvb, abs_offset - composite->start_offsets[i],
+ 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)) {
/*
{
guint abs_offset, abs_length;
- if (!check_offset_length_no_exception(tvb, offset, length,
- &abs_offset, &abs_length, exception)) {
+ if (!check_offset_length_no_exception(tvb->length, tvb->reported_length, offset, length,
+ &abs_offset, &abs_length, exception)) {
return NULL;
}
DISSECTOR_ASSERT(length <= 8);
if (offset < 0 || !tvb->real_data) {
- return ensure_contiguous(tvb, offset, length);
+ return ensure_contiguous(tvb, offset, length);
}
u_offset = offset;
}
DISSECTOR_ASSERT(member_tvb);
- if (check_offset_length_no_exception(member_tvb, abs_offset - composite->start_offsets[i],
+ if (check_offset_length_no_exception(member_tvb->length, member_tvb->reported_length, abs_offset - composite->start_offsets[i],
(gint) abs_length, &member_offset, &member_length, NULL)) {
DISSECTOR_ASSERT(!tvb->real_data);
* then iterate across the other member tvb's, copying their portions
* until we have copied all data.
*/
- retval = compute_offset_length(member_tvb, abs_offset - composite->start_offsets[i], -1,
+ retval = compute_offset_length(member_tvb->length, member_tvb->reported_length, abs_offset - composite->start_offsets[i], -1,
&member_offset, &member_length, NULL);
DISSECTOR_ASSERT(retval);
{
guint abs_offset, abs_length;
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
/*
* XXX - we should eliminate the "length = -1 means 'to the end
* of the tvbuff'" convention, and use other means to achieve
* instead, we check for a length <= 2^31-1.
*/
DISSECTOR_ASSERT(length <= 0x7FFFFFFF);
- check_offset_length(tvb, offset, (gint) length, &abs_offset, &abs_length);
+ check_offset_length(tvb->length, tvb->reported_length, offset, (gint) length, &abs_offset, &abs_length);
if (tvb->real_data) {
return memcpy(target, tvb->real_data + abs_offset, abs_length);
guint abs_offset, abs_length;
void *duped;
- check_offset_length(tvb, offset, (gint) length, &abs_offset, &abs_length);
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
+ check_offset_length(tvb->length, tvb->reported_length, offset, (gint) length, &abs_offset, &abs_length);
duped = g_malloc(abs_length);
return tvb_memcpy(tvb, duped, abs_offset, abs_length);
guint abs_offset, abs_length;
void *duped;
- check_offset_length(tvb, offset, (gint) length, &abs_offset, &abs_length);
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
+ check_offset_length(tvb->length, tvb->reported_length, offset, (gint) length, &abs_offset, &abs_length);
duped = ep_alloc(abs_length);
return tvb_memcpy(tvb, duped, abs_offset, abs_length);
#endif
exponent = ((exponent >> IEEE_SP_MANTISSA_WIDTH) - IEEE_SP_BIAS) -
- IEEE_SP_MANTISSA_WIDTH;
+ IEEE_SP_MANTISSA_WIDTH;
mantissa |= IEEE_SP_IMPLIED_BIT;
if (sign)
#endif
exponent = ((exponent >> IEEE_DP_MANTISSA_WIDTH) - IEEE_DP_BIAS) -
- IEEE_DP_MANTISSA_WIDTH;
+ IEEE_DP_MANTISSA_WIDTH;
mantissa |= IEEE_DP_IMPLIED_BIT;
if (sign)
}
static const guint8 bit_mask8[] = {
- 0xff,
- 0x7f,
- 0x3f,
- 0x1f,
- 0x0f,
- 0x07,
- 0x03,
- 0x01
+ 0xff,
+ 0x7f,
+ 0x3f,
+ 0x1f,
+ 0x0f,
+ 0x07,
+ 0x03,
+ 0x01
};
/* Bit offset mask for number of bits = 8 - 16 */
static const guint16 bit_mask16[] = {
- 0xffff,
- 0x7fff,
- 0x3fff,
- 0x1fff,
- 0x0fff,
- 0x07ff,
- 0x03ff,
- 0x01ff
+ 0xffff,
+ 0x7fff,
+ 0x3fff,
+ 0x1fff,
+ 0x0fff,
+ 0x07ff,
+ 0x03ff,
+ 0x01ff
};
/* Get 1 - 8 bits */
/* Get 9 - 16 bits */
/* Bit offset mask for number of bits = 16 - 32 */
static const guint32 bit_mask32[] = {
- 0xffffffff,
- 0x7fffffff,
- 0x3fffffff,
- 0x1fffffff,
- 0x0fffffff,
- 0x07ffffff,
- 0x03ffffff,
- 0x01ffffff
+ 0xffffffff,
+ 0x7fffffff,
+ 0x3fffffff,
+ 0x1fffffff,
+ 0x0fffffff,
+ 0x07ffffff,
+ 0x03ffffff,
+ 0x01ffffff
};
guint16
/* Bit offset mask for number of bits = 32 - 64 */
static const guint64 bit_mask64[] = {
- G_GINT64_CONSTANT(0xffffffffffffffffU),
- G_GINT64_CONSTANT(0x7fffffffffffffffU),
- G_GINT64_CONSTANT(0x3fffffffffffffffU),
- G_GINT64_CONSTANT(0x1fffffffffffffffU),
- G_GINT64_CONSTANT(0x0fffffffffffffffU),
- G_GINT64_CONSTANT(0x07ffffffffffffffU),
- G_GINT64_CONSTANT(0x03ffffffffffffffU),
- G_GINT64_CONSTANT(0x01ffffffffffffffU)
+ G_GINT64_CONSTANT(0xffffffffffffffffU),
+ G_GINT64_CONSTANT(0x7fffffffffffffffU),
+ G_GINT64_CONSTANT(0x3fffffffffffffffU),
+ G_GINT64_CONSTANT(0x1fffffffffffffffU),
+ G_GINT64_CONSTANT(0x0fffffffffffffffU),
+ G_GINT64_CONSTANT(0x07ffffffffffffffU),
+ G_GINT64_CONSTANT(0x03ffffffffffffffU),
+ G_GINT64_CONSTANT(0x01ffffffffffffffU)
};
guint32
return value;
}
+guint32
+tvb_get_bits(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian)
+{
+ /* This function can handle only up to 32 requested bits */
+ if (no_of_bits > 32)
+ DISSECTOR_ASSERT_NOT_REACHED();
+
+ if (no_of_bits == 0)
+ return 0;
+
+ /* Number of requested bits is in range [17, 32] */
+ if (no_of_bits > 16)
+ return tvb_get_bits32(tvb, bit_offset, no_of_bits, little_endian);
+
+ /* Number of requested bits is in range [9, 16] */
+ if (no_of_bits > 8)
+ return tvb_get_bits16(tvb, bit_offset, no_of_bits, little_endian);
+
+ /* Number of requested bits is in range [1, 8] */
+ return tvb_get_bits8(tvb, bit_offset, no_of_bits);
+}
+
/* Find first occurence of needle in tvbuff, starting at offset. Searches
* at most maxlength number of bytes; if maxlength is -1, searches to
* end of tvbuff.
guint tvbufflen;
guint limit;
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
+ check_offset_length(tvb->length, tvb->reported_length, offset, 0, &abs_offset, &junk_length);
/* Only search to end of tvbuff, w/o throwing exception. */
tvbufflen = tvb_length_remaining(tvb, abs_offset);
guint tvbufflen;
guint limit;
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
+ check_offset_length(tvb->length, tvb->reported_length, offset, 0, &abs_offset, &junk_length);
/* Only search to end of tvbuff, w/o throwing exception. */
tvbufflen = tvb_length_remaining(tvb, abs_offset);
guint abs_offset, junk_length;
gint nul_offset;
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
+ check_offset_length(tvb->length, tvb->reported_length, offset, 0, &abs_offset, &junk_length);
nul_offset = tvb_find_guint8(tvb, abs_offset, -1, 0);
if (nul_offset == -1) {
/*
* an exception.
*
* Did we hit the end of the captured data, or the end
- * of the actual data? If there's less captured data
+ * of the actual data? If there's less captured data
* than actual data, we presumably hit the end of the
* captured data, otherwise we hit the end of the actual
* data.
gint result_offset;
guint abs_offset, junk_length;
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
+ check_offset_length(tvb->length, tvb->reported_length, offset, 0, &abs_offset, &junk_length);
result_offset = tvb_find_guint8(tvb, abs_offset, maxlength, 0);
}
}
-/* Convert a string from Unicode to ASCII. At the moment we fake it by
+/* Convert a string from Unicode to ASCII. At the moment we fake it by
* replacing all non-ASCII characters with a '.' )-: The caller must
* free the result returned. The len parameter is the number of guint16's
* to convert from Unicode. */
return buffer;
}
-/* Convert a string from Unicode to ASCII. At the moment we fake it by
+/* Convert a string from Unicode to ASCII. At the moment we fake it by
* replacing all non-ASCII characters with a '.' )-: The len parameter is
* the number of guint16's to convert from Unicode.
*
gint len = size;
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);
-
}
/*
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);
}
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);
}
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);
}
* a null-terminated string, find the length of that string (and throw
* an exception if the tvbuff ends before we find the null), allocate
* a buffer big enough to hold the string, copy the string into it,
- * and return a pointer to the string. Also return the length of the
+ * and return a pointer to the string. Also return the length of the
* string (including the terminating null) through a pointer.
*/
guint8 *
size = tvb_strsize(tvb, offset);
strptr = g_malloc(size);
tvb_memcpy(tvb, strptr, offset, size);
- *lengthp = size;
+ if (lengthp)
+ *lengthp = size;
return strptr;
}
/*
* a null-terminated string, find the length of that string (and throw
* an exception if the tvbuff ends before we find the null), allocate
* a buffer big enough to hold the string, copy the string into it,
- * and return a pointer to the string. Also return the length of the
+ * and return a pointer to the string. Also return the length of the
* string (including the terminating null) through a pointer.
*
* This function allocates memory from a buffer with packet lifetime.
size = tvb_strsize(tvb, offset);
strptr = ep_alloc(size);
tvb_memcpy(tvb, strptr, offset, size);
- *lengthp = size;
+ if (lengthp)
+ *lengthp = size;
return strptr;
}
* a null-terminated string, find the length of that string (and throw
* an exception if the tvbuff ends before we find the null), allocate
* a buffer big enough to hold the string, copy the string into it,
- * and return a pointer to the string. Also return the length of the
+ * and return a pointer to the string. Also return the length of the
* string (including the terminating null) through a pointer.
*
* This function allocates memory from a buffer with capture session lifetime.
size = tvb_strsize(tvb, offset);
strptr = se_alloc(size);
tvb_memcpy(tvb, strptr, offset, size);
- *lengthp = size;
+ if (lengthp)
+ *lengthp = size;
return strptr;
}
gint limit, len;
gboolean decreased_max = FALSE;
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ check_offset_length(tvb->length, tvb->reported_length, offset, 0, &abs_offset, &junk_length);
/* There must at least be room for the terminating NUL. */
DISSECTOR_ASSERT(bufsize != 0);
{
gint bytes_copied;
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
return _tvb_get_nstringz(tvb, offset, bufsize, buffer, &bytes_copied);
}
{
gint len, bytes_copied;
+ DISSECTOR_ASSERT(tvb && tvb->initialized);
+
len = _tvb_get_nstringz(tvb, offset, bufsize, buffer, &bytes_copied);
if (len == -1) {
*
* Set "*next_offset" to the offset of the character past the line
* terminator, or past the end of the buffer if we don't find a line
- * terminator. (It's not set if we return -1.)
+ * terminator. (It's not set if we return -1.)
*/
gint
tvb_find_line_end(tvbuff_t *tvb, gint offset, int len, gint *next_offset,
- gboolean desegment)
+ gboolean desegment)
{
gint eob_offset;
gint eol_offset;
* Pretend the line runs to the end of the tvbuff.
*/
linelen = eob_offset - offset;
- *next_offset = eob_offset;
+ if (next_offset)
+ *next_offset = eob_offset;
}
} else {
/*
* character in the line, skipping over the last character
* in the line terminator.
*/
- *next_offset = eol_offset + 1;
+ if (next_offset)
+ *next_offset = eol_offset + 1;
}
return linelen;
}
*/
gint
tvb_find_line_end_unquoted(tvbuff_t *tvb, gint offset, int len,
- gint *next_offset)
+ gint *next_offset)
{
gint cur_offset, char_offset;
gboolean is_quoted;
cur_offset = offset;
is_quoted = FALSE;
for (;;) {
- /*
+ /*
* Is this part of the string quoted?
*/
if (is_quoted) {
* Yes - look only for the terminating quote.
*/
char_offset = tvb_find_guint8(tvb, cur_offset, len,
- '"');
+ '"');
} else {
/*
* Look either for a CR, an LF, or a '"'.
*/
char_offset = tvb_pbrk_guint8(tvb, cur_offset, len,
- (const guint8 *)"\r\n\"");
+ (const guint8 *)"\r\n\"");
}
if (char_offset == -1) {
/*
* We pretend the line runs to the end of the tvbuff.
*/
linelen = eob_offset - offset;
- *next_offset = eob_offset;
+ if (next_offset)
+ *next_offset = eob_offset;
break;
}
* Yes; is it followed by an LF?
*/
if (char_offset + 1 < eob_offset &&
- tvb_get_guint8(tvb, char_offset + 1)
- == '\n') {
+ tvb_get_guint8(tvb, char_offset + 1)
+ == '\n') {
/*
* Yes; skip over the CR.
*/
* over the last character in the line
* terminator, and quit.
*/
- *next_offset = char_offset + 1;
+ if (next_offset)
+ *next_offset = char_offset + 1;
break;
}
}
* We pretend the line runs to the end of the tvbuff.
*/
linelen = eob_offset - offset;
- *next_offset = eob_offset;
+ if (next_offset)
+ *next_offset = eob_offset;
break;
}
}
/*
* Copied from the mgcp dissector. (This function should be moved to /epan )
* tvb_skip_wsp - Returns the position in tvb of the first non-whitespace
- * character following offset or offset + maxlength -1 whichever
- * is smaller.
+ * character following offset or offset + maxlength -1 whichever
+ * is smaller.
*
* Parameters:
* tvb - The tvbuff in which we are skipping whitespace.
* whitespace.
*
* Returns: The position in tvb of the first non-whitespace
- * character following offset or offset + maxlength -1 whichever
- * is smaller.
+ * character following offset or offset + maxlength -1 whichever
+ * is smaller.
*/
gint tvb_skip_wsp(tvbuff_t* tvb, gint offset, gint maxlength)
{
/* Skip past spaces, tabs, CRs and LFs until run out or meet something else */
for (counter = offset;
- counter < end &&
- ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' ||
- tempchar == '\t' || tempchar == '\r' || tempchar == '\n');
- counter++);
+ counter < end &&
+ ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' ||
+ tempchar == '\t' || tempchar == '\r' || tempchar == '\n');
+ counter++);
return (counter);
}
const guint needle_len = needle_tvb->length;
const guint8 *location;
+ DISSECTOR_ASSERT(haystack_tvb && haystack_tvb->initialized);
+
if (haystack_tvb->length < 1 || needle_tvb->length < 1) {
return -1;
}
haystack_data = tvb_get_ptr(haystack_tvb, 0, -1);
needle_data = tvb_get_ptr(needle_tvb, 0, -1);
- check_offset_length(haystack_tvb, haystack_offset, -1,
+ check_offset_length(haystack_tvb->length, haystack_tvb->reported_length, haystack_offset, -1,
&haystack_abs_offset, &haystack_abs_length);
location = epan_memmem(haystack_data + haystack_abs_offset, haystack_abs_length,
tvbuff_t *
tvb_uncompress(tvbuff_t *tvb, int offset, int comprlen)
{
-
-
gint err = Z_OK;
guint bytes_out = 0;
guint8 *compr = NULL;
return NULL;
}
- strm = g_malloc0(sizeof(z_stream));
-
- if (strm == NULL) {
- return NULL;
- }
-
compr = tvb_memdup(tvb, offset, comprlen);
- if (!compr) {
- g_free(strm);
+ if (!compr)
return NULL;
- }
/*
* Assume that the uncompressed data is at least twice as big as
* the compressed size.
*/
bufsiz = tvb_length_remaining(tvb, offset) * 2;
-
- if (bufsiz < TVB_Z_MIN_BUFSIZ) {
- bufsiz = TVB_Z_MIN_BUFSIZ;
- } else if (bufsiz > TVB_Z_MAX_BUFSIZ) {
- bufsiz = TVB_Z_MIN_BUFSIZ;
- }
+ bufsiz = CLAMP(bufsiz, TVB_Z_MIN_BUFSIZ, TVB_Z_MAX_BUFSIZ);
#ifdef TVB_Z_DEBUG
printf("bufsiz: %u bytes\n", bufsiz);
next = compr;
+ strm = g_new0(z_stream, 1);
strm->next_in = next;
strm->avail_in = comprlen;
-
strmbuf = g_malloc0(bufsiz);
-
- if(strmbuf == NULL) {
- g_free(compr);
- g_free(strm);
- return NULL;
- }
-
strm->next_out = strmbuf;
strm->avail_out = bufsiz;
if (uncompr == NULL) {
uncompr = g_memdup(strmbuf, bytes_pass);
} else {
- guint8 *new_data = g_malloc0(bytes_out +
- bytes_pass);
-
- if (new_data == NULL) {
- inflateEnd(strm);
- g_free(strm);
- g_free(strmbuf);
- g_free(compr);
-
- if (uncompr != NULL) {
- g_free(uncompr);
- }
-
- return NULL;
- }
+ guint8 *new_data = g_malloc0(bytes_out + bytes_pass);
g_memmove(new_data, uncompr, bytes_out);
g_memmove((new_data + bytes_out), strmbuf,
- bytes_pass);
+ bytes_pass);
g_free(uncompr);
uncompr = new_data;
}
} else if (err == Z_DATA_ERROR && inits_done == 1
- && uncompr == NULL && (*compr == 0x1f) &&
- (*(compr + 1) == 0x8b)) {
+ && uncompr == NULL && (*compr == 0x1f) &&
+ (*(compr + 1) == 0x8b)) {
/*
* inflate() is supposed to handle both gzip and deflate
* streams automatically, but in reality it doesn't
if (flags & (1 << 2)) {
/* An Extra field is present. */
gint xsize = (gint)(*c |
- (*(c + 1) << 8));
+ (*(c + 1) << 8));
c += xsize;
}
err = inflateInit2(strm, wbits);
inits_done++;
} else if (err == Z_DATA_ERROR && uncompr == NULL &&
- inits_done <= 3) {
+ inits_done <= 3) {
/*
* Re-init the stream with a negative
if (uncompr != NULL) {
uncompr_tvb = tvb_new_real_data((guint8*) uncompr, bytes_out,
- bytes_out);
+ bytes_out);
tvb_set_free_cb(uncompr_tvb, g_free);
}
g_free(compr);
return new_tvb;
}
-