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