Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 439 insertions, 0 deletions

diff --git a/epan/ftypes/ftype-string.c b/epan/ftypes/ftype-string.c
new file mode 100644
index 0000000..28c33a7
--- /dev/null
+++ b/epan/ftypes/ftype-string.c
@@ -0,0 +1,439 @@
+/*
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 2001 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <ftypes-int.h>
+#include <string.h>
+
+#include <strutil.h>
+#include <wsutil/ws_assert.h>
+#include <wsutil/unicode-utils.h>
+
+
+static void
+string_fvalue_new(fvalue_t *fv)
+{
+	fv->value.strbuf = NULL;
+}
+
+static void
+string_fvalue_copy(fvalue_t *dst, const fvalue_t *src)
+{
+	dst->value.strbuf = wmem_strbuf_dup(NULL, src->value.strbuf);
+}
+
+static void
+string_fvalue_free(fvalue_t *fv)
+{
+	wmem_strbuf_destroy(fv->value.strbuf);
+}
+
+static void
+string_fvalue_set_strbuf(fvalue_t *fv, wmem_strbuf_t *value)
+{
+	DISSECTOR_ASSERT(value != NULL);
+
+	/* Free up the old value, if we have one */
+	string_fvalue_free(fv);
+
+	fv->value.strbuf = value;
+}
+
+static char *
+string_to_repr(wmem_allocator_t *scope, const fvalue_t *fv, ftrepr_t rtype _U_, int field_display _U_)
+{
+	if (rtype == FTREPR_DISPLAY || rtype == FTREPR_JSON) {
+		return ws_escape_null(scope, fv->value.strbuf->str, fv->value.strbuf->len, false);
+	}
+	if (rtype == FTREPR_DFILTER) {
+		return ws_escape_string_len(scope, fv->value.strbuf->str, fv->value.strbuf->len, true);
+	}
+	ws_assert_not_reached();
+}
+
+
+static const wmem_strbuf_t *
+value_get(fvalue_t *fv)
+{
+	return fv->value.strbuf;
+}
+
+static bool
+val_from_string(fvalue_t *fv, const char *s, size_t len, char **err_msg _U_)
+{
+	/* Free up the old value, if we have one */
+	string_fvalue_free(fv);
+
+	if (len > 0)
+		fv->value.strbuf = wmem_strbuf_new_len(NULL, s, len);
+	else
+		fv->value.strbuf = wmem_strbuf_new(NULL, s);
+
+	return true;
+}
+
+static bool
+val_from_literal(fvalue_t *fv, const char *s, bool allow_partial_value _U_, char **err_msg)
+{
+	/* Just turn it into a string */
+	/* XXX Should probably be a syntax error instead. It's more user-friendly to ask the
+	 * user to be explicit about the meaning of an unquoted literal than them trying to figure out
+	 * why a valid filter expression is giving wrong results. */
+	return val_from_string(fv, s, 0, err_msg);
+}
+
+static bool
+val_from_charconst(fvalue_t *fv, unsigned long num, char **err_msg)
+{
+	/* XXX Should be a syntax error if literal is also a syntax error. */
+
+	/* Free up the old value, if we have one */
+	string_fvalue_free(fv);
+	fv->value.strbuf = NULL;
+
+	if (num > UINT8_MAX) {
+		if (err_msg) {
+			*err_msg = ws_strdup_printf("%lu is too large for a byte value", num);
+		}
+		return false;
+	}
+
+	char c = (char)num;
+	fv->value.strbuf = wmem_strbuf_new(NULL, NULL);
+	wmem_strbuf_append_c(fv->value.strbuf, c);
+
+	return true;
+}
+
+static unsigned
+string_hash(const fvalue_t *fv)
+{
+	return g_str_hash(wmem_strbuf_get_str(fv->value.strbuf));
+}
+
+static bool
+string_is_zero(const fvalue_t *fv)
+{
+	return fv->value.strbuf == NULL || fv->value.strbuf->len == 0;
+}
+
+static unsigned
+len(fvalue_t *fv)
+{
+	/* g_utf8_strlen returns long for no apparent reason*/
+	long len = g_utf8_strlen(fv->value.strbuf->str, -1);
+	if (len < 0)
+		return 0;
+	return (unsigned)len;
+}
+
+static void
+slice(fvalue_t *fv, wmem_strbuf_t *buf, unsigned offset, unsigned length)
+{
+	const char *str = fv->value.strbuf->str;
+
+	/* Go to the starting offset */
+	const char *p = g_utf8_offset_to_pointer(str, (long)offset);
+	const char *n;
+	/* Copy 'length' codepoints to dst. Skip the terminating NULL */
+	while (*p != '\0' && length-- > 0) {
+		n = g_utf8_next_char(p);
+		/* Append n - p bytes (one codepoint)*/
+		wmem_strbuf_append_len(buf, p, n - p);
+		p = n;
+	}
+}
+
+static enum ft_result
+cmp_order(const fvalue_t *a, const fvalue_t *b, int *cmp)
+{
+	*cmp = wmem_strbuf_strcmp(a->value.strbuf, b->value.strbuf);
+	return FT_OK;
+}
+
+static enum ft_result
+cmp_contains(const fvalue_t *fv_a, const fvalue_t *fv_b, bool *contains)
+{
+	/* According to
+	* http://www.introl.com/introl-demo/Libraries/C/ANSI_C/string/strstr.html
+	* strstr() returns a non-NULL value if needle is an empty
+	* string. We don't that behavior for cmp_contains. */
+	if (fv_b->value.strbuf->len == 0) {
+		*contains = false;
+		return FT_OK;
+	}
+
+	if (wmem_strbuf_strstr(fv_a->value.strbuf, fv_b->value.strbuf)) {
+		*contains = true;
+	}
+	else {
+		*contains = false;
+	}
+
+	return FT_OK;
+}
+
+static enum ft_result
+cmp_matches(const fvalue_t *fv, const ws_regex_t *regex, bool *matches)
+{
+	wmem_strbuf_t *buf = fv->value.strbuf;
+
+	if (regex == NULL) {
+		return FT_BADARG;
+	}
+
+	*matches = ws_regex_matches_length(regex, buf->str, buf->len);
+	return FT_OK;
+}
+
+void
+ftype_register_string(void)
+{
+
+	static ftype_t string_type = {
+		FT_STRING,			/* ftype */
+		"FT_STRING",			/* name */
+		"Character string",		/* pretty_name */
+		0,				/* wire_size */
+		string_fvalue_new,		/* new_value */
+		string_fvalue_copy,		/* copy_value */
+		string_fvalue_free,		/* free_value */
+		val_from_literal,		/* val_from_literal */
+		val_from_string,		/* val_from_string */
+		val_from_charconst,		/* val_from_charconst */
+		string_to_repr,			/* val_to_string_repr */
+
+		NULL,				/* val_to_uinteger64 */
+		NULL,				/* val_to_sinteger64 */
+
+		{ .set_value_strbuf = string_fvalue_set_strbuf },	/* union set_value */
+		{ .get_value_strbuf = value_get },	/* union get_value */
+
+		cmp_order,
+		cmp_contains,
+		cmp_matches,
+
+		string_hash,			/* hash */
+		string_is_zero,			/* is_zero */
+		NULL,				/* is_negative */
+		len,
+		(FvalueSlice)slice,
+		NULL,				/* bitwise_and */
+		NULL,				/* unary_minus */
+		NULL,				/* add */
+		NULL,				/* subtract */
+		NULL,				/* multiply */
+		NULL,				/* divide */
+		NULL,				/* modulo */
+	};
+	static ftype_t stringz_type = {
+		FT_STRINGZ,			/* ftype */
+		"FT_STRINGZ",			/* name */
+		"Character string",		/* pretty name */
+		0,				/* wire_size */
+		string_fvalue_new,		/* new_value */
+		string_fvalue_copy,		/* copy_value */
+		string_fvalue_free,		/* free_value */
+		val_from_literal,		/* val_from_literal */
+		val_from_string,		/* val_from_string */
+		val_from_charconst,		/* val_from_charconst */
+		string_to_repr,			/* val_to_string_repr */
+
+		NULL,				/* val_to_uinteger64 */
+		NULL,				/* val_to_sinteger64 */
+
+		{ .set_value_strbuf = string_fvalue_set_strbuf },	/* union set_value */
+		{ .get_value_strbuf = value_get },	/* union get_value */
+
+		cmp_order,
+		cmp_contains,			/* cmp_contains */
+		cmp_matches,
+
+		string_hash,			/* hash */
+		string_is_zero,			/* is_zero */
+		NULL,				/* is_negative */
+		len,
+		(FvalueSlice)slice,
+		NULL,				/* bitwise_and */
+		NULL,				/* unary_minus */
+		NULL,				/* add */
+		NULL,				/* subtract */
+		NULL,				/* multiply */
+		NULL,				/* divide */
+		NULL,				/* modulo */
+	};
+	static ftype_t uint_string_type = {
+		FT_UINT_STRING,		/* ftype */
+		"FT_UINT_STRING",		/* name */
+		"Character string",		/* pretty_name */
+		0,				/* wire_size */
+		string_fvalue_new,		/* new_value */
+		string_fvalue_copy,		/* copy_value */
+		string_fvalue_free,		/* free_value */
+		val_from_literal,		/* val_from_literal */
+		val_from_string,		/* val_from_string */
+		val_from_charconst,		/* val_from_charconst */
+		string_to_repr,			/* val_to_string_repr */
+
+		NULL,				/* val_to_uinteger64 */
+		NULL,				/* val_to_sinteger64 */
+
+		{ .set_value_strbuf = string_fvalue_set_strbuf },	/* union set_value */
+		{ .get_value_strbuf = value_get },	/* union get_value */
+
+		cmp_order,
+		cmp_contains,			/* cmp_contains */
+		cmp_matches,
+
+		string_hash,			/* hash */
+		string_is_zero,			/* is_zero */
+		NULL,				/* is_negative */
+		len,
+		(FvalueSlice)slice,
+		NULL,				/* bitwise_and */
+		NULL,				/* unary_minus */
+		NULL,				/* add */
+		NULL,				/* subtract */
+		NULL,				/* multiply */
+		NULL,				/* divide */
+		NULL,				/* modulo */
+	};
+	static ftype_t stringzpad_type = {
+		FT_STRINGZPAD,			/* ftype */
+		"FT_STRINGZPAD",		/* name */
+		"Character string",		/* pretty name */
+		0,				/* wire_size */
+		string_fvalue_new,		/* new_value */
+		string_fvalue_copy,		/* copy_value */
+		string_fvalue_free,		/* free_value */
+		val_from_literal,		/* val_from_literal */
+		val_from_string,		/* val_from_string */
+		val_from_charconst,		/* val_from_charconst */
+		string_to_repr,			/* val_to_string_repr */
+
+		NULL,				/* val_to_uinteger64 */
+		NULL,				/* val_to_sinteger64 */
+
+		{ .set_value_strbuf = string_fvalue_set_strbuf },	/* union set_value */
+		{ .get_value_strbuf = value_get },	/* union get_value */
+
+		cmp_order,
+		cmp_contains,			/* cmp_contains */
+		cmp_matches,
+
+		string_hash,			/* hash */
+		string_is_zero,			/* is_zero */
+		NULL,				/* is_negative */
+		len,
+		(FvalueSlice)slice,
+		NULL,				/* bitwise_and */
+		NULL,				/* unary_minus */
+		NULL,				/* add */
+		NULL,				/* subtract */
+		NULL,				/* multiply */
+		NULL,				/* divide */
+		NULL,				/* modulo */
+	};
+	static ftype_t stringztrunc_type = {
+		FT_STRINGZTRUNC,		/* ftype */
+		"FT_STRINGZTRUNC",		/* name */
+		"Character string",		/* pretty name */
+		0,				/* wire_size */
+		string_fvalue_new,		/* new_value */
+		string_fvalue_copy,		/* copy_value */
+		string_fvalue_free,		/* free_value */
+		val_from_literal,		/* val_from_literal */
+		val_from_string,		/* val_from_string */
+		val_from_charconst,		/* val_from_charconst */
+		string_to_repr,			/* val_to_string_repr */
+
+		NULL,				/* val_to_uinteger64 */
+		NULL,				/* val_to_sinteger64 */
+
+		{ .set_value_strbuf = string_fvalue_set_strbuf },	/* union set_value */
+		{ .get_value_strbuf = value_get },	/* union get_value */
+
+		cmp_order,
+		cmp_contains,			/* cmp_contains */
+		cmp_matches,
+
+		string_hash,			/* hash */
+		string_is_zero,			/* is_zero */
+		NULL,				/* is_negative */
+		len,
+		(FvalueSlice)slice,
+		NULL,				/* bitwise_and */
+		NULL,				/* unary_minus */
+		NULL,				/* add */
+		NULL,				/* subtract */
+		NULL,				/* multiply */
+		NULL,				/* divide */
+		NULL,				/* modulo */
+	};
+
+	ftype_register(FT_STRING, &string_type);
+	ftype_register(FT_STRINGZ, &stringz_type);
+	ftype_register(FT_UINT_STRING, &uint_string_type);
+	ftype_register(FT_STRINGZPAD, &stringzpad_type);
+	ftype_register(FT_STRINGZTRUNC, &stringztrunc_type);
+}
+
+void
+ftype_register_pseudofields_string(int proto)
+{
+	static int hf_ft_string;
+	static int hf_ft_stringz;
+	static int hf_ft_uint_string;
+	static int hf_ft_stringzpad;
+	static int hf_ft_stringztrunc;
+
+	static hf_register_info hf_ftypes[] = {
+		{ &hf_ft_string,
+		    { "FT_STRING", "_ws.ftypes.string",
+			FT_STRING, BASE_NONE, NULL, 0x00,
+			NULL, HFILL }
+		},
+		{ &hf_ft_stringz,
+		    { "FT_STRINGZ", "_ws.ftypes.stringz",
+			FT_STRINGZ, BASE_NONE, NULL, 0x00,
+			NULL, HFILL }
+		},
+		{ &hf_ft_uint_string,
+		    { "FT_UINT_STRING", "_ws.ftypes.uint_string",
+			FT_UINT_STRING, BASE_NONE, NULL, 0x00,
+			NULL, HFILL }
+		},
+		{ &hf_ft_stringzpad,
+		    { "FT_STRINGZPAD", "_ws.ftypes.stringzpad",
+			FT_STRINGZPAD, BASE_NONE, NULL, 0x00,
+			NULL, HFILL }
+		},
+		{ &hf_ft_stringztrunc,
+		    { "FT_STRINGZTRUNC", "_ws.ftypes.stringztrunc",
+			FT_STRINGZTRUNC, BASE_NONE, NULL, 0x00,
+			NULL, HFILL }
+		},
+	};
+
+	proto_register_field_array(proto, hf_ftypes, array_length(hf_ftypes));
+}
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 8
+ * tab-width: 8
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=8 tabstop=8 noexpandtab:
+ * :indentSize=8:tabSize=8:noTabs=false:
+ */