diff --git a/epan/tvbuff.c b/epan/tvbuff.c
index 98968a0..db2cfd1 100644
--- a/epan/tvbuff.c
+++ b/epan/tvbuff.c
@@ -53,7 +53,7 @@
static const guint8*
ensure_contiguous_no_exception(tvbuff_t *tvb, const gint offset, const gint length,
- int *exception);
+ int *pexception);
static const guint8*
ensure_contiguous(tvbuff_t *tvb, const gint offset, const gint length);
@@ -241,45 +241,48 @@ tvb_new_child_real_data(tvbuff_t *parent, const guint8* data, const guint length
return 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
- * not. The integer ptrs are modified with the new offset and length.
- * No exception is thrown.
+/*
+ * Check whether that offset goes more than one byte past the
+ * end of the buffer.
*
- * XXX - we return TRUE, not FALSE, if the offset is positive and right
- * after the end of the tvbuff (i.e., equal to the length). We do this
- * so that a dissector constructing a subset tvbuff for the next protocol
- * will get a zero-length tvbuff, not an exception, if there's no data
- * left for the next protocol - we want the next protocol to be the one
- * 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 tvbuff_t *tvb,
- const gint offset, const gint length_val,
- guint *offset_ptr, guint *length_ptr, int *exception)
+ * If not, return 0; otherwise, return exception
+ */
+static inline int
+validate_offset(const tvbuff_t *tvb, const guint abs_offset)
{
- DISSECTOR_ASSERT(offset_ptr);
- DISSECTOR_ASSERT(length_ptr);
+ int exception;
+
+ if (G_LIKELY(abs_offset <= tvb->length))
+ exception = 0;
+ else if (abs_offset <= tvb->reported_length)
+ exception = BoundsError;
+ else {
+ if (tvb->flags & TVBUFF_FRAGMENT)
+ exception = FragmentBoundsError;
+ else
+ exception = ReportedBoundsError;
+ }
+
+ return exception;
+}
+
+static int
+compute_offset(const tvbuff_t *tvb, const gint offset, guint *offset_ptr)
+{
+ int exception;
- /* Compute the offset */
if (offset >= 0) {
/* Positive offset - relative to the beginning of the packet. */
if ((guint) offset > tvb->reported_length) {
- if (exception) {
- if (tvb->flags & TVBUFF_FRAGMENT) {
- *exception = FragmentBoundsError;
- } else {
- *exception = ReportedBoundsError;
- }
+ if (tvb->flags & TVBUFF_FRAGMENT) {
+ exception = FragmentBoundsError;
+ } else {
+ exception = ReportedBoundsError;
}
- return FALSE;
+ return exception;
}
else if ((guint) offset > tvb->length) {
- if (exception) {
- *exception = BoundsError;
- }
- return FALSE;
+ return BoundsError;
}
else {
*offset_ptr = offset;
@@ -288,95 +291,90 @@ compute_offset_length(const tvbuff_t *tvb,
else {
/* Negative offset - relative to the end of the packet. */
if ((guint) -offset > tvb->reported_length) {
- if (exception) {
- if (tvb->flags & TVBUFF_FRAGMENT) {
- *exception = FragmentBoundsError;
- } else {
- *exception = ReportedBoundsError;
- }
+ if (tvb->flags & TVBUFF_FRAGMENT) {
+ exception = FragmentBoundsError;
+ } else {
+ exception = ReportedBoundsError;
}
- return FALSE;
+ return exception;
}
else if ((guint) -offset > tvb->length) {
- if (exception) {
- *exception = BoundsError;
- }
- return FALSE;
+ return BoundsError;
}
else {
*offset_ptr = tvb->length + offset;
}
}
- /* Compute the length */
- if (length_val < -1) {
- if (exception) {
- /* XXX - ReportedBoundsError? */
- *exception = BoundsError;
- }
- return FALSE;
- }
- else if (length_val == -1) {
- *length_ptr = tvb->length - *offset_ptr;
- }
- else {
- *length_ptr = length_val;
- }
+ return 0;
+}
- return TRUE;
+static int
+compute_offset_and_remaining(const tvbuff_t *tvb, const gint offset, guint *offset_ptr, guint *rem_len)
+{
+ int exception;
+
+ exception = compute_offset(tvb, offset, offset_ptr);
+ if (!exception)
+ *rem_len = tvb->length - *offset_ptr;
+
+ return exception;
}
-static gboolean
+/* 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 integer indicating whether the offset is in bounds (0) or
+ * not (exception number). The integer ptrs are modified with the new offset and length.
+ * No exception is thrown.
+ *
+ * XXX - we return success (0), if the offset is positive and right
+ * after the end of the tvbuff (i.e., equal to the length). We do this
+ * so that a dissector constructing a subset tvbuff for the next protocol
+ * will get a zero-length tvbuff, not an exception, if there's no data
+ * left for the next protocol - we want the next protocol to be the one
+ * that gets an exception, so the error is reported as an error in that
+ * protocol rather than the containing protocol. */
+static int
check_offset_length_no_exception(const tvbuff_t *tvb,
const gint offset, gint const length_val,
- guint *offset_ptr, guint *length_ptr, int *exception)
+ guint *offset_ptr, guint *length_ptr)
{
- guint end_offset;
+ guint end_offset;
+ int exception;
- if (!compute_offset_length(tvb,
- offset, length_val, offset_ptr, length_ptr, exception)) {
- return FALSE;
+ DISSECTOR_ASSERT(offset_ptr);
+ DISSECTOR_ASSERT(length_ptr);
+
+ /* Compute the offset */
+ exception = compute_offset(tvb, offset, offset_ptr);
+ if (exception)
+ return exception;
+
+ if (length_val < -1) {
+ /* XXX - ReportedBoundsError? */
+ return BoundsError;
}
+ /* Compute the length */
+ if (length_val == -1)
+ *length_ptr = tvb->length - *offset_ptr;
+ else
+ *length_ptr = length_val;
+
/*
* Compute the offset of the first byte past the length.
*/
end_offset = *offset_ptr + *length_ptr;
/*
- * Check for an overflow, and clamp "end_offset" at the maximum
- * if we got an overflow - that should force us to indicate that
- * we're past the end of the tvbuff.
+ * Check for an overflow
*/
if (end_offset < *offset_ptr)
- end_offset = UINT_MAX;
-
- /*
- * Check whether that offset goes more than one byte past the
- * end of the buffer.
- *
- * If not, return TRUE; otherwise, return FALSE and, if "exception"
- * is non-null, return the appropriate exception through it.
- */
- if (end_offset <= tvb->length) {
- return TRUE;
- }
- else {
- if (exception) {
- if (end_offset <= tvb->reported_length) {
- *exception = BoundsError;
- }
- else {
- if (tvb->flags & TVBUFF_FRAGMENT) {
- *exception = FragmentBoundsError;
- } else {
- *exception = ReportedBoundsError;
- }
- }
- }
+ exception = BoundsError;
+ else
+ exception = validate_offset(tvb, end_offset);
- return FALSE;
- }
+ return exception;
}
/* Checks (+/-) offset and length and throws an exception if
@@ -387,13 +385,11 @@ check_offset_length(const tvbuff_t *tvb,
const gint offset, gint const length_val,
guint *offset_ptr, guint *length_ptr)
{
- int exception = 0;
-
- if (!check_offset_length_no_exception(tvb,
- offset, length_val, offset_ptr, length_ptr, &exception)) {
- DISSECTOR_ASSERT(exception > 0);
+ int exception;
+
+ exception = check_offset_length_no_exception(tvb, offset, length_val, offset_ptr, length_ptr);
+ if (exception)
THROW(exception);
- }
}
static tvbuff_t *
@@ -538,7 +534,7 @@ tvb_new_octet_aligned(tvbuff_t *tvb, guint32 bit_offset, gint32 no_of_bits)
right = 8 - left; /* for right-shifting */
if (no_of_bits == -1) {
- datalen = tvb_length_remaining(tvb, byte_offset);
+ datalen = tvb_captured_length_remaining(tvb, byte_offset);
remaining_bits = 0;
} else {
datalen = no_of_bits >> 3;
@@ -560,7 +556,7 @@ tvb_new_octet_aligned(tvbuff_t *tvb, guint32 bit_offset, gint32 no_of_bits)
* if non extra byte is available, the last shifted byte requires
* special treatment
*/
- if (tvb_length_remaining(tvb, byte_offset) > datalen) {
+ if (tvb_captured_length_remaining(tvb, byte_offset) > datalen) {
data = tvb_get_ptr(tvb, byte_offset, datalen + 1);
/* Do this allocation AFTER tvb_get_ptr() (which could throw an exception) */
@@ -679,7 +675,7 @@ tvb_composite_finalize(tvbuff_t *tvb)
guint
-tvb_length(const tvbuff_t *tvb)
+tvb_captured_length(const tvbuff_t *tvb)
{
DISSECTOR_ASSERT(tvb && tvb->initialized);
@@ -687,32 +683,33 @@ tvb_length(const tvbuff_t *tvb)
}
gint
-tvb_length_remaining(const tvbuff_t *tvb, const gint offset)
+tvb_captured_length_remaining(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
+ guint abs_offset, rem_length;
+ int exception;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL)) {
- return abs_length;
- }
- else {
- return -1;
- }
+ exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &rem_length);
+ if (exception)
+ return 0;
+
+ return rem_length;
}
guint
-tvb_ensure_length_remaining(const tvbuff_t *tvb, const gint offset)
+tvb_ensure_captured_length_remaining(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
+ guint abs_offset, rem_length;
int exception;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (!compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, &exception)) {
+ exception = compute_offset_and_remaining(tvb, offset, &abs_offset, &rem_length);
+ if (exception)
THROW(exception);
- }
- if (abs_length == 0) {
+
+ if (rem_length == 0) {
/*
* This routine ensures there's at least one byte available.
* There aren't any bytes available, so throw the appropriate
@@ -727,7 +724,7 @@ tvb_ensure_length_remaining(const tvbuff_t *tvb, const gint offset)
} else
THROW(BoundsError);
}
- return abs_length;
+ return rem_length;
}
@@ -739,18 +736,15 @@ gboolean
tvb_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length)
{
guint abs_offset, abs_length;
+ int exception;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (!compute_offset_length(tvb, offset, length, &abs_offset, &abs_length, NULL))
+ exception = check_offset_length_no_exception(tvb, offset, length, &abs_offset, &abs_length);
+ if (exception)
return FALSE;
- if (abs_offset + abs_length <= tvb->length) {
- return TRUE;
- }
- else {
- return FALSE;
- }
+ return TRUE;
}
/* Validates that 'length' bytes are available starting from
@@ -781,10 +775,13 @@ tvb_ensure_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length
gboolean
tvb_offset_exists(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
+ guint abs_offset;
+ int exception;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (!compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL))
+
+ exception = compute_offset(tvb, offset, &abs_offset);
+ if (exception)
return FALSE;
if (abs_offset < tvb->length) {
@@ -806,19 +803,19 @@ tvb_reported_length(const tvbuff_t *tvb)
gint
tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset)
{
- guint abs_offset, abs_length;
+ guint abs_offset;
+ int exception;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- if (compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL)) {
- if (tvb->reported_length >= abs_offset)
- return tvb->reported_length - abs_offset;
- else
- return -1;
- }
- else {
- return -1;
- }
+ exception = compute_offset(tvb, offset, &abs_offset);
+ if (exception)
+ return 0;
+
+ if (tvb->reported_length >= abs_offset)
+ return tvb->reported_length - abs_offset;
+ else
+ return 0;
}
/* Set the reported length of a tvbuff to a given value; used for protocols
@@ -896,6 +893,7 @@ composite_ensure_contiguous_no_exception(tvbuff_t *tvb, const guint abs_offset,
tvbuff_t *member_tvb = NULL;
guint member_offset, member_length;
GSList *slist;
+ int exception;
DISSECTOR_ASSERT(tvb->type == TVBUFF_COMPOSITE);
@@ -913,10 +911,11 @@ composite_ensure_contiguous_no_exception(tvbuff_t *tvb, const guint abs_offset,
}
DISSECTOR_ASSERT(member_tvb);
- if (check_offset_length_no_exception(member_tvb,
+ exception = check_offset_length_no_exception(member_tvb,
abs_offset - composite->start_offsets[i],
- abs_length, &member_offset, &member_length, NULL)) {
+ abs_length, &member_offset, &member_length);
+ if (!exception) {
/*
* The range is, in fact, contiguous within member_tvb.
*/
@@ -932,12 +931,15 @@ composite_ensure_contiguous_no_exception(tvbuff_t *tvb, const guint abs_offset,
}
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 *pexception)
{
guint abs_offset, abs_length;
+ int exception;
- if (!check_offset_length_no_exception(tvb, offset, length,
- &abs_offset, &abs_length, exception)) {
+ exception = check_offset_length_no_exception(tvb, offset, length, &abs_offset, &abs_length);
+ if (exception) {
+ if (pexception)
+ *pexception = exception;
return NULL;
}
@@ -1046,7 +1048,7 @@ composite_memcpy(tvbuff_t *tvb, guint8* target, guint abs_offset, size_t abs_len
tvb_comp_t *composite;
tvbuff_t *member_tvb = NULL;
guint member_offset, member_length;
- gboolean retval;
+ int exception;
GSList *slist;
DISSECTOR_ASSERT(tvb->type == TVBUFF_COMPOSITE);
@@ -1065,9 +1067,10 @@ composite_memcpy(tvbuff_t *tvb, guint8* target, guint abs_offset, size_t abs_len
}
DISSECTOR_ASSERT(member_tvb);
- if (check_offset_length_no_exception(member_tvb, abs_offset - composite->start_offsets[i],
- (gint) abs_length, &member_offset, &member_length, NULL)) {
-
+ exception = check_offset_length_no_exception(member_tvb, abs_offset - composite->start_offsets[i],
+ (gint) abs_length, &member_offset, &member_length);
+
+ if (!exception) {
DISSECTOR_ASSERT(!tvb->real_data);
return tvb_memcpy(member_tvb, target, member_offset, member_length);
}
@@ -1077,9 +1080,9 @@ composite_memcpy(tvbuff_t *tvb, guint8* target, guint abs_offset, size_t abs_len
* 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,
- &member_offset, &member_length, NULL);
- DISSECTOR_ASSERT(retval);
+ exception = compute_offset_and_remaining(member_tvb, abs_offset - composite->start_offsets[i],
+ &member_offset, &member_length);
+ DISSECTOR_ASSERT(!exception);
/* composite_memcpy() can't handle a member_length of zero. */
DISSECTOR_ASSERT(member_length);
@@ -1909,6 +1912,21 @@ tvb_get_bits(tvbuff_t *tvb, const guint bit_offset, const gint no_of_bits, const
return (guint32)_tvb_get_bits64(tvb, bit_offset, no_of_bits);
}
+static gint
+tvb_find_guint8_generic(tvbuff_t *tvb, guint abs_offset, guint limit, guint8 needle)
+{
+ const guint8 *ptr;
+ const guint8 *result;
+
+ ptr = tvb_get_ptr(tvb, abs_offset, limit);
+
+ result = (const guint8 *) memchr(ptr, needle, limit);
+ if (!result)
+ return -1;
+
+ return (gint) ((result - ptr) + abs_offset);
+}
+
/* Find first occurrence of needle in tvbuff, starting at offset. Searches
* at most maxlength number of bytes; if maxlength is -1, searches to
* end of tvbuff.
@@ -1920,16 +1938,15 @@ 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 abs_offset;
guint tvbufflen;
guint limit;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ check_offset_length(tvb, offset, -1, &abs_offset, &tvbufflen);
/* Only search to end of tvbuff, w/o throwing exception. */
- tvbufflen = tvb_length_remaining(tvb, abs_offset);
if (maxlength == -1) {
/* No maximum length specified; search to end of tvbuff. */
limit = tvbufflen;
@@ -1985,16 +2002,15 @@ 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 abs_offset;
guint tvbufflen;
guint limit;
DISSECTOR_ASSERT(tvb && tvb->initialized);
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ check_offset_length(tvb, offset, -1, &abs_offset, &tvbufflen);
/* Only search to end of tvbuff, w/o throwing exception. */
- tvbufflen = tvb_length_remaining(tvb, abs_offset);
if (maxlength == -1) {
/* No maximum length specified; search to end of tvbuff. */
limit = tvbufflen;
@@ -2845,11 +2861,12 @@ static gint
_tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer, gint *bytes_copied)
{
gint stringlen;
- guint abs_offset, junk_length;
+ guint abs_offset;
gint limit, len;
gboolean decreased_max = FALSE;
- check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+ /* Only read to end of tvbuff, w/o throwing exception. */
+ check_offset_length(tvb, offset, -1, &abs_offset, &len);
/* There must at least be room for the terminating NUL. */
DISSECTOR_ASSERT(bufsize != 0);
@@ -2861,9 +2878,6 @@ _tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8*
return 0;
}
- /* Only read to end of tvbuff, w/o throwing exception. */
- len = tvb_length_remaining(tvb, abs_offset);
-
/* check_offset_length() won't throw an exception if we're
* looking at the byte immediately after the end of the tvbuff. */
if (len == 0) {
@@ -2984,7 +2998,7 @@ tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len, gint *next_offset,
guchar found_needle = 0;
if (len == -1)
- len = tvb_length_remaining(tvb, offset);
+ len = tvb_captured_length_remaining(tvb, offset);
/*
* XXX - what if "len" is still -1, meaning "offset is past the
* end of the tvbuff"?
@@ -3100,7 +3114,7 @@ tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len, gint *next
int linelen;
if (len == -1)
- len = tvb_length_remaining(tvb, offset);
+ len = tvb_captured_length_remaining(tvb, offset);
/*
* XXX - what if "len" is still -1, meaning "offset is past the
* end of the tvbuff"?
@@ -3238,7 +3252,7 @@ tvb_skip_wsp(tvbuff_t *tvb, const gint offset, const gint maxlength)
guint8 tempchar;
/* Get the length remaining */
- tvb_len = tvb_length(tvb);
+ tvb_len = tvb_captured_length(tvb);
end = offset + maxlength;
if (end >= tvb_len)
{
@@ -3310,7 +3324,7 @@ tvb_bcd_dig_to_ep_str(tvbuff_t *tvb, const gint offset, const gint len, dgt_set_
dgt = &Dgt1_9_bcd;
if (len == -1) {
- length = tvb_length(tvb);
+ length = tvb_captured_length(tvb);
if (length < offset) {
return "";
}
diff --git a/epan/tvbuff.h b/epan/tvbuff.h
index 8950feb..f815c1f 100644
--- a/epan/tvbuff.h
+++ b/epan/tvbuff.h
@@ -213,16 +213,28 @@ WS_DLL_PUBLIC tvbuff_t* tvb_new_composite(void);
WS_DLL_PUBLIC void tvb_composite_finalize(tvbuff_t* tvb);
-/* Get total length of buffer */
-WS_DLL_PUBLIC guint tvb_length(const tvbuff_t*);
+/* Get amount of captured data in the buffer (which is *NOT* necessarily the
+ * * length of the packet). You probably want tvb_reported_length instead. */
+WS_DLL_PUBLIC guint tvb_captured_length(const tvbuff_t *tvb);
+
+/* DEPRECATED, do not use in new code, call tvb_captured_length directly! */
+#define tvb_length tvb_captured_length
/** Computes bytes to end of buffer, from offset (which can be negative,
- * to indicate bytes from end of buffer). Function returns -1 to
- * indicate that offset is out of bounds. No exception is thrown. */
-WS_DLL_PUBLIC gint tvb_length_remaining(const tvbuff_t*, const gint offset);
+ * to indicate bytes from end of buffer). Function returns 0 if offset is out
+ * of bounds. No exception is thrown. */
+WS_DLL_PUBLIC gint tvb_captured_length_remaining(const tvbuff_t *tvb, const gint offset);
+
+/* DEPRECATED, do not use in new code, call tvb_captured_length_remaining directly! */
+#define tvb_length_remaining tvb_captured_length_remaining
+
/** Same as above, but throws an exception if the offset is out of bounds. */
-WS_DLL_PUBLIC guint tvb_ensure_length_remaining(const tvbuff_t*, const gint offset);
+WS_DLL_PUBLIC guint tvb_ensure_captured_length_remaining(const tvbuff_t *tvb,
+ const gint offset);
+
+/* DEPRECATED, do not use in new code, call tvb_ensure_captured_length_remaining directly! */
+#define tvb_ensure_length_remaining tvb_ensure_captured_length_remaining
/* Checks (w/o throwing exception) that the bytes referred to by
* 'offset'/'length' actually exist in the buffer */
@@ -240,8 +252,7 @@ WS_DLL_PUBLIC guint tvb_reported_length(const tvbuff_t*);
/** Computes bytes of reported packet data to end of buffer, from offset
* (which can be negative, to indicate bytes from end of buffer). Function
- * returns -1 to indicate that offset is out of bounds. No exception is
- * thrown. */
+ * returns 0 if offset is out of bounds. No exception is thrown. */
WS_DLL_PUBLIC gint tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset);
/** Set the reported length of a tvbuff to a given value; used for protocols