First step in moving core Ethereal routines to libepan.

svn path=/trunk/; revision=2458

1 files changed, 1144 insertions, 0 deletions

diff --git a/epan/tvbuff.c b/epan/tvbuff.c
new file mode 100644
index 0000000000..74071276ad
--- /dev/null
+++ b/epan/tvbuff.c
@@ -0,0 +1,1144 @@
+/* tvbuff.c
+ *
+ * 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.
+ *
+ * "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.
+ *
+ * $Id: tvbuff.c,v 1.1 2000/09/27 04:54:53 gram Exp $
+ *
+ * Copyright (c) 2000 by Gilbert Ramirez <gram@xiexie.org>
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@zing.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <string.h>
+
+#include "pint.h"
+#include "tvbuff.h"
+#include "strutil.h"
+
+typedef struct {
+	/* The backing tvbuff_t */
+	tvbuff_t	*tvb;
+
+	/* The offset/length of 'tvb' to which I'm privy */
+	guint		offset;
+	guint		length;
+
+} tvb_backing_t;
+
+typedef struct {
+	GSList		*tvbs;
+
+	/* Used for quick testing to see if this
+	 * is the tvbuff that a COMPOSITE is
+	 * interested in. */
+	guint		*start_offsets;
+	guint		*end_offsets;
+
+} tvb_comp_t;
+
+struct tvbuff {
+	/* Record-keeping */
+	tvbuff_type		type;
+	gboolean		initialized;
+	guint			usage_count;
+
+	/* The tvbuffs in which this tvbuff is a member
+	 * (that is, a backing tvbuff for a TVBUFF_SUBSET
+	 * or a member for a TVB_COMPOSITE) */
+	GSList			*used_in;
+
+	/* TVBUFF_SUBSET and TVBUFF_COMPOSITE keep track
+	 * of the other tvbuff's they use */
+	union {
+		tvb_backing_t	subset;
+		tvb_comp_t	composite;
+	} tvbuffs;
+
+	/* We're either a TVBUFF_REAL_DATA or a
+	 * TVBUFF_SUBSET that has a backing buffer that
+	 * has real_data != NULL, or a TVBUFF_COMPOSITE
+	 * which has flattened its data due to a call
+	 * to tvb_get_ptr().
+	 */
+	guint8			*real_data;
+
+	/* Length of virtual buffer (and/or real_data). */
+	guint			length;
+
+	/* Reported length. */
+	guint			reported_length;
+
+	/* Offset from beginning of first TVBUFF_REAL. */
+	gint			raw_offset;
+
+	/* Func to call when actually freed */
+	tvbuff_free_cb_t	free_cb;
+};
+
+static guint8*
+ensure_contiguous(tvbuff_t *tvb, gint offset, gint length);
+
+/* We dole out tvbuff's from this memchunk. */
+GMemChunk *tvbuff_mem_chunk = NULL;
+
+void
+tvbuff_init(void)
+{
+	if (!tvbuff_mem_chunk)
+		tvbuff_mem_chunk = g_mem_chunk_create(tvbuff_t, 20, G_ALLOC_AND_FREE);
+}
+
+void
+tvbuff_cleanup(void)
+{
+	if (tvbuff_mem_chunk)
+		g_mem_chunk_destroy(tvbuff_mem_chunk);
+
+	tvbuff_mem_chunk = NULL;
+}
+
+
+
+
+static void
+tvb_init(tvbuff_t *tvb, tvbuff_type type)
+{
+	tvb_backing_t	*backing;
+	tvb_comp_t	*composite;
+
+	tvb->type		= type;
+	tvb->initialized	= FALSE;
+	tvb->usage_count	= 1;
+	tvb->length		= 0;
+	tvb->reported_length	= 0;
+	tvb->free_cb		= NULL;
+	tvb->real_data		= NULL;
+	tvb->raw_offset		= -1;
+	tvb->used_in		= NULL;
+
+	switch(type) {
+		case TVBUFF_REAL_DATA:
+			/* Nothing */
+			break;
+
+		case TVBUFF_SUBSET:
+			backing = &tvb->tvbuffs.subset;
+			backing->tvb	= NULL;
+			backing->offset	= 0;
+			backing->length	= 0;
+			break;
+
+		case TVBUFF_COMPOSITE:
+			composite = &tvb->tvbuffs.composite;
+			composite->tvbs			= NULL;
+			composite->start_offsets	= NULL;
+			composite->end_offsets		= NULL;
+			break;
+	}
+}
+
+
+tvbuff_t*
+tvb_new(tvbuff_type type)
+{
+	tvbuff_t	*tvb;
+
+	tvb = g_chunk_new(tvbuff_t, tvbuff_mem_chunk);
+	g_assert(tvb);
+
+	tvb_init(tvb, type);
+
+	return tvb;
+}
+
+/* We accept a void* instead of a field_info* to satisfy CLEANUP_POP */
+static void
+tvb_free_void(void *tvb)
+{
+	tvb_free((tvbuff_t*)tvb);
+}
+
+
+
+void
+tvb_free(tvbuff_t* tvb)
+{
+	tvbuff_t	*member_tvb;
+	tvb_comp_t	*composite;
+	GSList		*slist;
+
+	tvb->usage_count--;
+
+	if (tvb->usage_count == 0) {
+		switch (tvb->type) {
+		case TVBUFF_REAL_DATA:
+			if (tvb->free_cb) {
+				tvb->free_cb(tvb->real_data);
+			}
+			break;
+
+		case TVBUFF_SUBSET:
+			/* This will be NULL if tvb_new_subset() fails because
+			 * reported_length < -1 */
+			if (tvb->tvbuffs.subset.tvb) {
+				tvb_decrement_usage_count(tvb->tvbuffs.subset.tvb, 1);
+			}
+			break;
+
+		case TVBUFF_COMPOSITE:
+			composite = &tvb->tvbuffs.composite;
+			for (slist = composite->tvbs; slist != NULL ; slist = slist->next) {
+				member_tvb = slist->data;
+				tvb_decrement_usage_count(member_tvb, 1);
+			}
+
+			g_slist_free(composite->tvbs);
+
+			if (composite->start_offsets)
+				g_free(composite->start_offsets);
+			if (composite->end_offsets)
+				g_free(composite->end_offsets);
+			if (tvb->real_data)
+				g_free(tvb->real_data);
+
+			break;
+		}
+
+		if (tvb->used_in) {
+			g_slist_free(tvb->used_in);
+		}
+
+		g_chunk_free(tvb, tvbuff_mem_chunk);
+	}
+}
+
+guint
+tvb_increment_usage_count(tvbuff_t* tvb, guint count)
+{
+	tvb->usage_count += count;
+
+	return tvb->usage_count;
+}
+
+guint
+tvb_decrement_usage_count(tvbuff_t* tvb, guint count)
+{
+	if (tvb->usage_count <= count) {
+		tvb->usage_count = 1;
+		tvb_free(tvb);
+		return 0;
+	}
+	else {
+		tvb->usage_count -= count;
+		return tvb->usage_count;
+	}
+
+}
+
+void
+tvb_free_chain(tvbuff_t* tvb)
+{
+	GSList		*slist;
+
+	/* Recursively call tvb_free_chain() */
+	for (slist = tvb->used_in; slist != NULL ; slist = slist->next) {
+		tvb_free_chain( (tvbuff_t*)slist->data );
+	}
+
+	/* Stop the recursion */
+	tvb_free(tvb);
+}
+
+
+
+void
+tvb_set_free_cb(tvbuff_t* tvb, tvbuff_free_cb_t func)
+{
+	g_assert(tvb->type == TVBUFF_REAL_DATA);
+	tvb->free_cb = func;
+}
+
+void
+tvb_set_real_data(tvbuff_t* tvb, const guint8* data, guint length, gint reported_length)
+{
+	g_assert(tvb->type == TVBUFF_REAL_DATA);
+	g_assert(!tvb->initialized);
+
+	if (reported_length < -1) {
+		THROW(ReportedBoundsError);
+	}
+
+	tvb->real_data		= (gpointer) data;
+	tvb->length		= length;
+	tvb->reported_length	= reported_length;
+	tvb->initialized	= TRUE;
+}
+
+tvbuff_t*
+tvb_new_real_data(const guint8* data, guint length, gint reported_length)
+{
+	tvbuff_t	*tvb;
+
+	tvb = tvb_new(TVBUFF_REAL_DATA);
+
+	CLEANUP_PUSH(tvb_free_void, tvb);
+
+	tvb_set_real_data(tvb, data, length, reported_length);
+
+	CLEANUP_POP;
+
+	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.
+ *
+ * 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(tvbuff_t *tvb, gint offset, gint length,
+		guint *offset_ptr, guint *length_ptr, int *exception)
+{
+	g_assert(offset_ptr);
+	g_assert(length_ptr);
+
+	/* Compute the offset */
+	if (offset >= 0) {
+		/* Positive offset - relative to the beginning of the packet. */
+		if (offset > tvb->reported_length) {
+			if (exception) {
+				*exception = ReportedBoundsError;
+			}
+			return FALSE;
+		}
+		else if (offset > tvb->length) {
+			if (exception) {
+				*exception = BoundsError;
+			}
+			return FALSE;
+		}
+		else {
+			*offset_ptr = offset;
+		}
+	}
+	else {
+		/* Negative offset - relative to the end of the packet. */
+		if (-offset > tvb->reported_length) {
+			if (exception) {
+				*exception = ReportedBoundsError;
+			}
+			return FALSE;
+		}
+		else if (-offset > tvb->length) {
+			if (exception) {
+				*exception = BoundsError;
+			}
+			return FALSE;
+		}
+		else {
+			*offset_ptr = tvb->length + offset;
+		}
+	}
+
+	/* Compute the length */
+	g_assert(length >= -1);
+	if (length == -1) {
+		*length_ptr = tvb->length - *offset_ptr;
+	}
+	else {
+		*length_ptr = length;
+	}
+
+	return TRUE;
+}
+
+
+static gboolean
+check_offset_length_no_exception(tvbuff_t *tvb, gint offset, gint length,
+		guint *offset_ptr, guint *length_ptr, int *exception)
+{
+	g_assert(tvb->initialized);
+
+	if (!compute_offset_length(tvb, offset, length, offset_ptr, length_ptr, exception)) {
+		return FALSE;
+	}
+
+	if (*offset_ptr + *length_ptr <= tvb->length) {
+		return TRUE;
+	}
+	else if (*offset_ptr + *length_ptr <= tvb->reported_length) {
+		if (exception) {
+			*exception = BoundsError;
+		}
+		return FALSE;
+	}
+	else {
+		if (exception) {
+			*exception = ReportedBoundsError;
+		}
+		return FALSE;
+	}
+
+	g_assert_not_reached();
+}
+
+/* Checks (+/-) offset and length and throws BoundsError if
+ * 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,
+		guint *offset_ptr, guint *length_ptr)
+{
+	int exception = 0;
+
+	if (!check_offset_length_no_exception(tvb, offset, length, offset_ptr, length_ptr, &exception)) {
+		g_assert(exception > 0);
+		THROW(exception);
+	}
+	return;
+}
+
+static void
+add_to_used_in_list(tvbuff_t *tvb, tvbuff_t *used_in)
+{
+	tvb->used_in = g_slist_prepend(tvb->used_in, used_in);
+}
+
+void
+tvb_set_subset(tvbuff_t *tvb, tvbuff_t *backing,
+		gint backing_offset, gint backing_length, gint reported_length)
+{
+	g_assert(tvb->type == TVBUFF_SUBSET);
+	g_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_increment_usage_count(backing, 1);
+	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;
+	}
+	else {
+		tvb->reported_length	= reported_length;
+	}
+	tvb->initialized		= TRUE;
+	add_to_used_in_list(backing, tvb);
+
+	/* Optimization. If the backing buffer has a pointer to contiguous, real data,
+	 * then we can point directly to our starting offset in that buffer */
+	if (backing->real_data != NULL) {
+		tvb->real_data = backing->real_data + tvb->tvbuffs.subset.offset;
+	}
+}
+
+
+tvbuff_t*
+tvb_new_subset(tvbuff_t *backing, gint backing_offset, gint backing_length, gint reported_length)
+{
+	tvbuff_t	*tvb;
+
+	tvb = tvb_new(TVBUFF_SUBSET);
+
+	CLEANUP_PUSH(tvb_free_void, tvb);
+
+	tvb_set_subset(tvb, backing, backing_offset, backing_length, reported_length);
+
+	CLEANUP_POP;
+
+	return tvb;
+}
+
+void
+tvb_composite_append(tvbuff_t* tvb, tvbuff_t* member)
+{
+	tvb_comp_t	*composite;
+
+	g_assert(!tvb->initialized);
+	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;
+
+	g_assert(!tvb->initialized);
+	composite = &tvb->tvbuffs.composite;
+	composite->tvbs = g_slist_prepend( composite->tvbs, member );
+}
+
+tvbuff_t*
+tvb_new_composite(void)
+{
+	return tvb_new(TVBUFF_COMPOSITE);
+}
+
+void
+tvb_composite_finalize(tvbuff_t* tvb)
+{
+	GSList		*slist;
+	guint		num_members;
+	tvbuff_t	*member_tvb;
+	tvb_comp_t	*composite;
+	int		i = 0;
+
+	g_assert(!tvb->initialized);
+	g_assert(tvb->length == 0);
+
+	composite = &tvb->tvbuffs.composite;
+	num_members = g_slist_length(composite->tvbs);
+
+	composite->start_offsets = g_new(guint, num_members);
+	composite->end_offsets = g_new(guint, num_members);
+
+	for (slist = composite->tvbs; slist != NULL; slist = slist->next) {
+		g_assert(i < num_members);
+		member_tvb = slist->data;
+		composite->start_offsets[i] = tvb->length;
+		tvb->length += member_tvb->length;
+		composite->end_offsets[i] = tvb->length - 1;
+		i++;
+	}
+
+	tvb->initialized = TRUE;
+}
+
+
+
+guint
+tvb_length(tvbuff_t* tvb)
+{
+	g_assert(tvb->initialized);
+
+	return tvb->length;
+}
+
+guint
+tvb_length_remaining(tvbuff_t *tvb, gint offset)
+{
+	guint	abs_offset, abs_length;
+
+	g_assert(tvb->initialized);
+
+	if (compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL)) {
+		return abs_length;
+	}
+	else {
+		return -1;
+	}
+}
+
+
+
+/* Validates that 'length' bytes are available starting from
+ * offset (pos/neg). Does not throw BoundsError exception. */
+gboolean
+tvb_bytes_exist(tvbuff_t *tvb, gint offset, gint length)
+{
+	guint		abs_offset, abs_length;
+
+	g_assert(tvb->initialized);
+
+	if (!compute_offset_length(tvb, offset, length, &abs_offset, &abs_length, NULL))
+		return FALSE;
+
+	if (abs_offset + abs_length <= tvb->length) {
+		return TRUE;
+	}
+	else {
+		return FALSE;
+	}
+}
+
+gboolean
+tvb_offset_exists(tvbuff_t *tvb, gint offset)
+{
+	guint		abs_offset, abs_length;
+
+	g_assert(tvb->initialized);
+	if (!compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL))
+		return FALSE;
+
+	if (abs_offset < tvb->length) {
+		return TRUE;
+	}
+	else {
+		return FALSE;
+	}
+}
+
+guint
+tvb_reported_length(tvbuff_t* tvb)
+{
+	g_assert(tvb->initialized);
+
+	return tvb->reported_length;
+}
+
+
+
+
+static guint8*
+first_real_data_ptr(tvbuff_t *tvb)
+{
+	tvbuff_t	*member;
+
+	switch(tvb->type) {
+		case TVBUFF_REAL_DATA:
+			return tvb->real_data;
+		case TVBUFF_SUBSET:
+			member = tvb->tvbuffs.subset.tvb;
+			return first_real_data_ptr(member);
+		case TVBUFF_COMPOSITE:
+			member = tvb->tvbuffs.composite.tvbs->data;
+			return first_real_data_ptr(member);
+	}
+
+	g_assert_not_reached();
+	return NULL;
+}
+
+static int
+offset_from_real_beginning(tvbuff_t *tvb, int counter)
+{
+	tvbuff_t	*member;
+
+	switch(tvb->type) {
+		case TVBUFF_REAL_DATA:
+			return counter;
+		case TVBUFF_SUBSET:
+			member = tvb->tvbuffs.subset.tvb;
+			return offset_from_real_beginning(member, counter + tvb->tvbuffs.subset.offset);
+		case TVBUFF_COMPOSITE:
+			member = tvb->tvbuffs.composite.tvbs->data;
+			return offset_from_real_beginning(member, counter);
+	}
+
+	g_assert_not_reached();
+	return 0;
+}
+
+gint
+tvb_raw_offset(tvbuff_t *tvb)
+{
+	if (tvb->raw_offset == -1) {
+		tvb->raw_offset = offset_from_real_beginning(tvb, 0);
+	}
+	return tvb->raw_offset;
+}
+
+void
+tvb_compat(tvbuff_t *tvb, const guint8 **pd, int *offset)
+{
+	g_assert(tvb->initialized);
+	*pd = first_real_data_ptr(tvb);
+	*offset = tvb_raw_offset(tvb);
+}
+
+
+static guint8*
+composite_ensure_contiguous(tvbuff_t *tvb, guint abs_offset, guint abs_length)
+{
+	guint		i, num_members;
+	tvb_comp_t	*composite;
+	tvbuff_t	*member_tvb = NULL;
+	guint		member_offset, member_length;
+	GSList		*slist;
+
+	g_assert(tvb->type == TVBUFF_COMPOSITE);
+
+	/* Maybe the range specified by offset/length
+	 * is contiguous inside one of the member tvbuffs */
+	composite = &tvb->tvbuffs.composite;
+	num_members = g_slist_length(composite->tvbs);
+
+	for (i = 0; i < num_members; i++) {
+		if (abs_offset <= composite->end_offsets[i]) {
+			slist = g_slist_nth(composite->tvbs, i);
+			member_tvb = slist->data;
+			break;
+		}
+	}
+	g_assert(member_tvb);
+
+	if (check_offset_length_no_exception(member_tvb, abs_offset - composite->start_offsets[i],
+				abs_length, &member_offset, &member_length, NULL)) {
+
+		g_assert(!tvb->real_data);
+		return ensure_contiguous(member_tvb, member_offset, member_length);
+	}
+	else {
+		tvb->real_data = tvb_memdup(tvb, 0, -1);
+		return tvb->real_data + abs_offset;
+	}
+
+	g_assert_not_reached();
+	return NULL;
+}
+
+static guint8*
+ensure_contiguous(tvbuff_t *tvb, gint offset, gint length)
+{
+	guint	abs_offset, abs_length;
+
+	check_offset_length(tvb, offset, length, &abs_offset, &abs_length);
+
+	if (tvb->real_data) {
+		return tvb->real_data + abs_offset;
+	}
+	else {
+		switch(tvb->type) {
+			case TVBUFF_REAL_DATA:
+				g_assert_not_reached();
+			case TVBUFF_SUBSET:
+				return ensure_contiguous(tvb->tvbuffs.subset.tvb,
+						abs_offset - tvb->tvbuffs.subset.offset,
+						abs_length);
+			case TVBUFF_COMPOSITE:
+				return composite_ensure_contiguous(tvb, abs_offset, abs_length);
+		}
+	}
+
+	g_assert_not_reached();
+	return NULL;
+}
+
+static const guint8*
+guint8_find(const guint8* haystack, size_t haystacklen, guint8 needle)
+{
+	const guint8	*b;
+	int		i;
+
+	for (b = haystack, i = 0; i < haystacklen; i++, b++) {
+		if (*b == needle) {
+			return b;
+		}
+	}
+
+	return NULL;
+}
+
+
+
+/************** ACCESSORS **************/
+
+static guint8*
+composite_memcpy(tvbuff_t *tvb, guint8* target, guint abs_offset, guint abs_length)
+{
+	guint		i, num_members;
+	tvb_comp_t	*composite;
+	tvbuff_t	*member_tvb = NULL;
+	guint		member_offset, member_length;
+	gboolean	retval;
+	GSList		*slist;
+
+	g_assert(tvb->type == TVBUFF_COMPOSITE);
+
+	/* Maybe the range specified by offset/length
+	 * is contiguous inside one of the member tvbuffs */
+	composite = &tvb->tvbuffs.composite;
+	num_members = g_slist_length(composite->tvbs);
+
+	for (i = 0; i < num_members; i++) {
+		if (abs_offset <= composite->end_offsets[i]) {
+			slist = g_slist_nth(composite->tvbs, i);
+			member_tvb = slist->data;
+			break;
+		}
+	}
+	g_assert(member_tvb);
+
+	if (check_offset_length_no_exception(member_tvb, abs_offset - composite->start_offsets[i],
+				abs_length, &member_offset, &member_length, NULL)) {
+
+		g_assert(!tvb->real_data);
+		return tvb_memcpy(member_tvb, target, member_offset, member_length);
+	}
+	else {
+		/* The requested data is non-contiguous inside
+		 * the member tvb. We have to memcpy() the part that's in the member tvb,
+		 * 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);
+		g_assert(retval);
+
+		tvb_memcpy(member_tvb, target, member_offset, member_length);
+		abs_offset	+= member_length;
+		abs_length	-= member_length;
+
+		/* Recurse */
+		if (abs_length > 0) {
+			composite_memcpy(tvb, target + member_length, abs_offset, abs_length);
+		}
+
+		return target;
+	}
+
+	g_assert_not_reached();
+	return NULL;
+}
+
+guint8*
+tvb_memcpy(tvbuff_t *tvb, guint8* target, gint offset, gint length)
+{
+	guint	abs_offset, abs_length;
+
+	g_assert(length >= -1);
+	check_offset_length(tvb, offset, length, &abs_offset, &abs_length);
+
+	if (tvb->real_data) {
+		return (guint8*) memcpy(target, tvb->real_data + abs_offset, abs_length);
+	}
+
+	switch(tvb->type) {
+		case TVBUFF_REAL_DATA:
+			g_assert_not_reached();
+
+		case TVBUFF_SUBSET:
+			return tvb_memcpy(tvb->tvbuffs.subset.tvb, target,
+					abs_offset - tvb->tvbuffs.subset.offset,
+					abs_length);
+
+		case TVBUFF_COMPOSITE:
+			return composite_memcpy(tvb, target, offset, length);
+	}
+
+	g_assert_not_reached();
+	return NULL;
+}
+
+
+guint8*
+tvb_memdup(tvbuff_t *tvb, gint offset, gint length)
+{
+	guint	abs_offset, abs_length;
+	guint8	*duped;
+
+	check_offset_length(tvb, offset, length, &abs_offset, &abs_length);
+
+	duped = g_malloc(abs_length);
+	return tvb_memcpy(tvb, duped, abs_offset, abs_length);
+}
+
+
+	
+guint8*
+tvb_get_ptr(tvbuff_t *tvb, gint offset, gint length)
+{
+	return ensure_contiguous(tvb, offset, length);
+}
+
+guint8
+tvb_get_guint8(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, sizeof(guint8));
+	return *ptr;
+}
+
+guint16
+tvb_get_ntohs(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, sizeof(guint16));
+	return pntohs(ptr);
+}
+
+guint32
+tvb_get_ntoh24(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, 3);
+	return pntoh24(ptr);
+}
+
+guint32
+tvb_get_ntohl(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, sizeof(guint32));
+	return pntohl(ptr);
+}
+
+#ifdef G_HAVE_GINT64
+guint64
+tvb_get_ntohll(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, sizeof(guint64));
+	return pntohll(ptr);
+}
+#endif
+
+guint16
+tvb_get_letohs(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, sizeof(guint16));
+	return pletohs(ptr);
+}
+
+guint32
+tvb_get_letoh24(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, 3);
+	return pletoh24(ptr);
+}
+
+guint32
+tvb_get_letohl(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, sizeof(guint32));
+	return pletohl(ptr);
+}
+
+#ifdef G_HAVE_GINT64
+guint64
+tvb_get_letohll(tvbuff_t *tvb, gint offset)
+{
+	guint8* ptr;
+
+	ptr = ensure_contiguous(tvb, offset, sizeof(guint64));
+	return pletohll(ptr);
+}
+#endif
+
+
+/* Find first occurence of needle in tvbuff, starting at offset. Searches
+ * at most maxlength number of bytes. Returns the offset of the found needle,
+ * or -1 if not found. Will not throw an exception, even if maxlength exceeds
+ * boundary of tvbuff; in that case, -1 will be returned if the boundary is
+ * reached before finding needle. */
+gint
+tvb_find_guint8(tvbuff_t *tvb, gint offset, guint maxlength, guint8 needle)
+{
+	guint		abs_offset, junk_length;
+	const guint8	*result;
+	guint		limit;
+
+	check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+
+	/* Only search to end of tvbuff, w/o throwing exception. */
+	if (tvb_length_remaining(tvb, abs_offset) < maxlength) {
+		limit = maxlength - (tvb_length(tvb) - abs_offset);
+	}
+	else {
+		limit = maxlength;
+	}
+
+	/* If we have real data, perform our search now. */
+	if (tvb->real_data) {
+		result = guint8_find(tvb->real_data + abs_offset, limit, needle);
+		if (result == NULL) {
+			return -1;
+		}
+		else {
+			return result - tvb->real_data;
+		}
+	}
+
+	switch(tvb->type) {
+		case TVBUFF_REAL_DATA:
+			g_assert_not_reached();
+
+		case TVBUFF_SUBSET:
+			return tvb_find_guint8(tvb->tvbuffs.subset.tvb,
+					abs_offset - tvb->tvbuffs.subset.offset,
+					limit, needle);
+
+		case TVBUFF_COMPOSITE:
+			g_assert_not_reached();
+			/* XXX - return composite_find_guint8(tvb, offset, limit, needle); */
+	}
+
+	g_assert_not_reached();
+	return -1;
+}
+
+/* Find length of string by looking for end of string ('\0'), up to
+ * 'max_length' characters'. Returns -1 if 'max_length' reached
+ * before finding EOS. */
+gint
+tvb_strnlen(tvbuff_t *tvb, gint offset, guint maxlength)
+{
+	gint	result_offset;
+	guint	abs_offset, junk_length;
+
+	check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+
+	result_offset = tvb_find_guint8(tvb, abs_offset, maxlength, 0);
+
+	if (result_offset == -1) {
+		return -1;
+	}
+	else {
+		return result_offset;
+	}
+}
+
+/*
+ * Implement strneql etc
+ */
+
+/* Call strncmp after checking if enough chars left, otherwise return -1 */
+gint
+tvb_strneql(tvbuff_t *tvb, gint offset, guint8 *str, gint size)
+{
+  guint8 *ptr;
+
+  ptr = ensure_contiguous(tvb, offset, size);
+
+  if (ptr) {
+
+    int cmp = strncmp(ptr, str, size);
+
+    return (cmp == 0 ? 0 : -1);  /* Make it -1 if comparison failed */
+
+  }
+  else {
+
+    return -1;   /* Not enough chars in the TVB */
+
+  }
+
+}
+
+/*
+ * Format the data in the tvb from offset for length ...
+ */
+
+guint8 *
+tvb_format_text(tvbuff_t *tvb, gint offset, gint size)
+{
+  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);
+
+  }
+
+  return format_text(ptr, len);
+ 
+}
+
+/* Looks for a stringz (NUL-terminated string) in tvbuff and copies
+ * no more than maxlength number of bytes, including terminating NUL, to buffer.
+ * Returns length of string (not including terminating NUL), or -1 if the string was
+ * truncated in the buffer due to not having reached the terminating NUL.
+ * In this way, it acts like snprintf().
+ */
+gint
+tvb_get_nstringz(tvbuff_t *tvb, gint offset, guint maxlength, guint8* buffer)
+{
+	gint	stringlen, NUL_offset;
+	guint	abs_offset, junk_length;
+	gint	limit;
+
+	check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
+
+	if (maxlength == 0) {
+		buffer[0] = 0;
+		return 0;
+	}
+
+	/* Only copy to end of tvbuff, w/o throwing exception. */
+	if (tvb_length_remaining(tvb, abs_offset) < maxlength) {
+		limit = maxlength - (tvb_length(tvb) - abs_offset);
+	}
+	else {
+		limit = maxlength;
+	}
+
+	NUL_offset = tvb_strnlen(tvb, abs_offset, limit);
+
+	/* If NUL wasn't found, copy the data and return -1 */
+	if (NUL_offset == -1) {
+		tvb_memcpy(tvb, buffer, abs_offset, limit);
+		return -1;
+	}
+
+	/* Copy the string to buffer */
+	stringlen = NUL_offset - abs_offset;
+	tvb_memcpy(tvb, buffer, abs_offset, stringlen + 1);
+	return stringlen;
+}
+
+/* Like tvb_get_nstringz(), but never returns -1. The string is guaranteed to
+ * have a terminating NUL. If the string was truncated when copied into buffer,
+ * a NUL is placed at the end of buffer to terminate it.
+ */
+gint
+tvb_get_nstringz0(tvbuff_t *tvb, gint offset, guint maxlength, guint8* buffer)
+{
+	gint	len;
+
+	len = tvb_get_nstringz(tvb, offset, maxlength, buffer);
+
+	if (len == -1) {
+		buffer[maxlength] = 0;
+		return maxlength - 1;
+	}
+	else {
+		return len;
+	}
+}