2001-02-01 20:31:21 +00:00
|
|
|
/*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2001-02-01 20:31:21 +00:00
|
|
|
* Copyright 2001 Gerald Combs
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2018-02-08 16:59:17 +00:00
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
2001-02-01 20:31:21 +00:00
|
|
|
*/
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "dfilter-int.h"
|
2005-07-23 06:51:57 +00:00
|
|
|
#include "semcheck.h"
|
2001-02-01 20:21:25 +00:00
|
|
|
#include "syntax-tree.h"
|
|
|
|
#include "sttype-range.h"
|
|
|
|
#include "sttype-test.h"
|
2015-08-19 03:03:41 +00:00
|
|
|
#include "sttype-set.h"
|
2006-05-02 14:26:17 +00:00
|
|
|
#include "sttype-function.h"
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/exceptions.h>
|
|
|
|
#include <epan/packet.h>
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2016-07-24 12:53:39 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
#include <wsutil/ws_printf.h> /* ws_debug_printf */
|
|
|
|
#endif
|
|
|
|
|
2013-11-10 13:14:09 +00:00
|
|
|
#include <ftypes/ftypes-int.h>
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
/* Enable debug logging by defining AM_CFLAGS
|
|
|
|
* so that it contains "-DDEBUG_dfilter".
|
|
|
|
* Usage: DebugLog(("Error: string=%s\n", str)); */
|
2007-04-17 15:13:17 +00:00
|
|
|
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
#define DebugLog(x) \
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("%s:%u: ", __FILE__, __LINE__); \
|
|
|
|
ws_debug_printf x; \
|
2003-12-09 23:02:40 +00:00
|
|
|
fflush(stdout)
|
|
|
|
#else
|
|
|
|
#define DebugLog(x) ;
|
|
|
|
#endif
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
semcheck(dfwork_t *dfw, stnode_t *st_node, GPtrArray *deprecated);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
static stnode_t*
|
2015-01-18 10:22:19 +00:00
|
|
|
check_param_entity(dfwork_t *dfw, stnode_t *st_node);
|
2009-05-31 19:46:31 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
typedef gboolean (*FtypeCanFunc)(enum ftenum);
|
|
|
|
|
|
|
|
/* Compares to ftenum_t's and decides if they're
|
|
|
|
* compatible or not (if they're the same basic type) */
|
|
|
|
static gboolean
|
|
|
|
compatible_ftypes(ftenum_t a, ftenum_t b)
|
|
|
|
{
|
|
|
|
switch (a) {
|
|
|
|
case FT_NONE:
|
|
|
|
case FT_PROTOCOL:
|
2003-07-25 03:44:05 +00:00
|
|
|
case FT_FLOAT: /* XXX - should be able to compare with INT */
|
|
|
|
case FT_DOUBLE: /* XXX - should be able to compare with INT */
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_ABSOLUTE_TIME:
|
|
|
|
case FT_RELATIVE_TIME:
|
2015-09-06 17:01:47 +00:00
|
|
|
case FT_IEEE_11073_SFLOAT:
|
|
|
|
case FT_IEEE_11073_FLOAT:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_IPv4:
|
|
|
|
case FT_IPv6:
|
|
|
|
case FT_IPXNET:
|
2014-12-17 20:19:20 +00:00
|
|
|
case FT_INT40: /* XXX - should be able to compare with INT */
|
|
|
|
case FT_UINT40: /* XXX - should be able to compare with INT */
|
|
|
|
case FT_INT48: /* XXX - should be able to compare with INT */
|
|
|
|
case FT_UINT48: /* XXX - should be able to compare with INT */
|
|
|
|
case FT_INT56: /* XXX - should be able to compare with INT */
|
|
|
|
case FT_UINT56: /* XXX - should be able to compare with INT */
|
2003-07-25 03:44:05 +00:00
|
|
|
case FT_INT64: /* XXX - should be able to compare with INT */
|
|
|
|
case FT_UINT64: /* XXX - should be able to compare with INT */
|
2011-05-08 10:23:53 +00:00
|
|
|
case FT_EUI64: /* XXX - should be able to compare with INT */
|
2001-02-01 20:21:25 +00:00
|
|
|
return a == b;
|
|
|
|
|
|
|
|
case FT_ETHER:
|
|
|
|
case FT_BYTES:
|
2002-05-09 23:50:34 +00:00
|
|
|
case FT_UINT_BYTES:
|
2005-07-04 13:04:53 +00:00
|
|
|
case FT_GUID:
|
2005-12-02 13:16:58 +00:00
|
|
|
case FT_OID:
|
2012-08-02 16:54:43 +00:00
|
|
|
case FT_AX25:
|
2013-07-28 00:07:49 +00:00
|
|
|
case FT_VINES:
|
2014-12-24 05:06:35 +00:00
|
|
|
case FT_FCWWN:
|
2013-10-06 02:31:10 +00:00
|
|
|
case FT_REL_OID:
|
2013-12-23 17:57:57 +00:00
|
|
|
case FT_SYSTEM_ID:
|
2011-05-08 10:23:53 +00:00
|
|
|
|
2014-12-24 05:06:35 +00:00
|
|
|
return (b == FT_ETHER || b == FT_BYTES || b == FT_UINT_BYTES || b == FT_GUID || b == FT_OID || b == FT_AX25 || b == FT_VINES || b == FT_FCWWN || b == FT_REL_OID || b == FT_SYSTEM_ID);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
case FT_BOOLEAN:
|
2002-12-19 02:58:53 +00:00
|
|
|
case FT_FRAMENUM:
|
2016-09-19 01:48:50 +00:00
|
|
|
case FT_CHAR:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
|
|
|
case FT_INT8:
|
|
|
|
case FT_INT16:
|
|
|
|
case FT_INT24:
|
|
|
|
case FT_INT32:
|
|
|
|
switch (b) {
|
|
|
|
case FT_BOOLEAN:
|
2002-12-19 02:58:53 +00:00
|
|
|
case FT_FRAMENUM:
|
2016-09-19 01:48:50 +00:00
|
|
|
case FT_CHAR:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
|
|
|
case FT_INT8:
|
|
|
|
case FT_INT16:
|
|
|
|
case FT_INT24:
|
|
|
|
case FT_INT32:
|
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
|
|
|
case FT_UINT_STRING:
|
2014-04-12 22:26:34 +00:00
|
|
|
case FT_STRINGZPAD:
|
2001-02-01 20:21:25 +00:00
|
|
|
switch (b) {
|
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
|
|
|
case FT_UINT_STRING:
|
2014-04-12 22:26:34 +00:00
|
|
|
case FT_STRINGZPAD:
|
2001-02-01 20:21:25 +00:00
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2003-12-09 23:02:40 +00:00
|
|
|
case FT_PCRE:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert_not_reached();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
/* Gets an fvalue from a string, and sets the error message on failure. */
|
|
|
|
static fvalue_t*
|
|
|
|
dfilter_fvalue_from_unparsed(dfwork_t *dfw, ftenum_t ftype, const char *s, gboolean allow_partial_value)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Don't set the error message if it's already set.
|
|
|
|
*/
|
|
|
|
return fvalue_from_unparsed(ftype, s, allow_partial_value,
|
|
|
|
dfw->error_message == NULL ? &dfw->error_message : NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Gets an fvalue from a string, and sets the error message on failure. */
|
|
|
|
static fvalue_t*
|
|
|
|
dfilter_fvalue_from_string(dfwork_t *dfw, ftenum_t ftype, const char *s)
|
|
|
|
{
|
|
|
|
return fvalue_from_string(ftype, s,
|
|
|
|
dfw->error_message == NULL ? &dfw->error_message : NULL);
|
|
|
|
}
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
/* Creates a FT_UINT32 fvalue with a given value. */
|
|
|
|
static fvalue_t*
|
|
|
|
mk_uint32_fvalue(guint32 val)
|
|
|
|
{
|
|
|
|
fvalue_t *fv;
|
|
|
|
|
|
|
|
fv = fvalue_new(FT_UINT32);
|
2007-01-18 11:02:26 +00:00
|
|
|
fvalue_set_uinteger(fv, val);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
return fv;
|
|
|
|
}
|
|
|
|
|
2013-07-26 23:51:00 +00:00
|
|
|
/* Creates a FT_UINT64 fvalue with a given value. */
|
|
|
|
static fvalue_t*
|
|
|
|
mk_uint64_fvalue(guint64 val)
|
|
|
|
{
|
|
|
|
fvalue_t *fv;
|
|
|
|
|
|
|
|
fv = fvalue_new(FT_UINT64);
|
2014-12-17 20:19:20 +00:00
|
|
|
fvalue_set_uinteger64(fv, val);
|
2013-07-26 23:51:00 +00:00
|
|
|
|
|
|
|
return fv;
|
|
|
|
}
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
/* Try to make an fvalue from a string using a value_string or true_false_string.
|
|
|
|
* This works only for ftypes that are integers. Returns the created fvalue_t*
|
|
|
|
* or NULL if impossible. */
|
|
|
|
static fvalue_t*
|
2015-01-18 10:22:19 +00:00
|
|
|
mk_fvalue_from_val_string(dfwork_t *dfw, header_field_info *hfinfo, char *s)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2002-11-28 01:46:14 +00:00
|
|
|
static const true_false_string default_tf = { "True", "False" };
|
|
|
|
const true_false_string *tf = &default_tf;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
/* Early return? */
|
|
|
|
switch(hfinfo->type) {
|
|
|
|
case FT_NONE:
|
|
|
|
case FT_PROTOCOL:
|
2002-08-24 19:45:28 +00:00
|
|
|
case FT_FLOAT:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_DOUBLE:
|
2015-09-06 17:01:47 +00:00
|
|
|
case FT_IEEE_11073_SFLOAT:
|
|
|
|
case FT_IEEE_11073_FLOAT:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_ABSOLUTE_TIME:
|
|
|
|
case FT_RELATIVE_TIME:
|
|
|
|
case FT_IPv4:
|
|
|
|
case FT_IPv6:
|
|
|
|
case FT_IPXNET:
|
2012-08-02 16:54:43 +00:00
|
|
|
case FT_AX25:
|
2013-07-28 00:07:49 +00:00
|
|
|
case FT_VINES:
|
2014-12-24 05:06:35 +00:00
|
|
|
case FT_FCWWN:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_ETHER:
|
|
|
|
case FT_BYTES:
|
2002-05-09 23:50:34 +00:00
|
|
|
case FT_UINT_BYTES:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
|
|
|
case FT_UINT_STRING:
|
2014-04-12 22:26:34 +00:00
|
|
|
case FT_STRINGZPAD:
|
2011-05-08 10:23:53 +00:00
|
|
|
case FT_EUI64:
|
2003-12-09 23:02:40 +00:00
|
|
|
case FT_PCRE:
|
2005-07-04 13:04:53 +00:00
|
|
|
case FT_GUID:
|
2005-12-02 13:16:58 +00:00
|
|
|
case FT_OID:
|
2013-10-06 02:31:10 +00:00
|
|
|
case FT_REL_OID:
|
2013-12-23 17:57:57 +00:00
|
|
|
case FT_SYSTEM_ID:
|
2015-07-02 08:48:58 +00:00
|
|
|
case FT_FRAMENUM: /* hfinfo->strings contains ft_framenum_type_t, not strings */
|
2009-07-03 01:11:23 +00:00
|
|
|
return NULL;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
case FT_BOOLEAN:
|
2016-09-19 01:48:50 +00:00
|
|
|
case FT_CHAR:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
2014-12-17 20:19:20 +00:00
|
|
|
case FT_UINT40:
|
|
|
|
case FT_UINT48:
|
|
|
|
case FT_UINT56:
|
2013-07-26 23:51:00 +00:00
|
|
|
case FT_UINT64:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_INT8:
|
|
|
|
case FT_INT16:
|
|
|
|
case FT_INT24:
|
|
|
|
case FT_INT32:
|
2014-12-17 20:19:20 +00:00
|
|
|
case FT_INT40:
|
|
|
|
case FT_INT48:
|
|
|
|
case FT_INT56:
|
2013-07-26 23:51:00 +00:00
|
|
|
case FT_INT64:
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TRUE/FALSE *always* exist for FT_BOOLEAN. */
|
|
|
|
if (hfinfo->type == FT_BOOLEAN) {
|
|
|
|
if (hfinfo->strings) {
|
2013-03-05 06:16:45 +00:00
|
|
|
tf = (const true_false_string *)hfinfo->strings;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
if (g_ascii_strcasecmp(s, tf->true_string) == 0) {
|
2016-03-15 21:20:02 +00:00
|
|
|
return mk_uint64_fvalue(TRUE);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
else if (g_ascii_strcasecmp(s, tf->false_string) == 0) {
|
2016-03-15 21:20:02 +00:00
|
|
|
return mk_uint64_fvalue(FALSE);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-01-18 10:22:19 +00:00
|
|
|
/*
|
|
|
|
* Prefer this error message to whatever error message
|
|
|
|
* has already been set.
|
|
|
|
*/
|
|
|
|
g_free(dfw->error_message);
|
|
|
|
dfw->error_message = NULL;
|
|
|
|
dfilter_fail(dfw, "\"%s\" cannot be found among the possible values for %s.",
|
2001-02-01 20:21:25 +00:00
|
|
|
s, hfinfo->abbrev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do val_strings exist? */
|
|
|
|
if (!hfinfo->strings) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s cannot accept strings as values.",
|
2001-02-01 20:21:25 +00:00
|
|
|
hfinfo->abbrev);
|
2009-07-03 01:11:23 +00:00
|
|
|
return NULL;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
/* Reset the error message, since *something* interesting will happen,
|
|
|
|
* and the error message will be more interesting than any error message
|
|
|
|
* I happen to have now. */
|
|
|
|
g_free(dfw->error_message);
|
|
|
|
dfw->error_message = NULL;
|
2011-10-28 20:13:56 +00:00
|
|
|
|
2009-07-03 01:11:23 +00:00
|
|
|
if (hfinfo->display & BASE_RANGE_STRING) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" cannot accept [range] strings as values.",
|
2009-07-03 01:11:23 +00:00
|
|
|
hfinfo->abbrev);
|
|
|
|
}
|
2013-07-26 23:51:00 +00:00
|
|
|
else if (hfinfo->display & BASE_VAL64_STRING) {
|
|
|
|
const val64_string *vals = (const val64_string *)hfinfo->strings;
|
|
|
|
|
|
|
|
while (vals->strptr != NULL) {
|
|
|
|
if (g_ascii_strcasecmp(s, vals->strptr) == 0) {
|
|
|
|
return mk_uint64_fvalue(vals->value);
|
|
|
|
}
|
|
|
|
vals++;
|
|
|
|
}
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" cannot be found among the possible values for %s.",
|
2013-07-26 23:51:00 +00:00
|
|
|
s, hfinfo->abbrev);
|
|
|
|
}
|
2011-01-22 15:15:51 +00:00
|
|
|
else if (hfinfo->display == BASE_CUSTOM) {
|
2010-12-03 22:59:16 +00:00
|
|
|
/* If a user wants to match against a custom string, we would
|
|
|
|
* somehow have to have the integer value here to pass it in
|
|
|
|
* to the custom-display function. But we don't have an
|
|
|
|
* integer, we have the string they're trying to match.
|
|
|
|
* -><-
|
|
|
|
*/
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" cannot accept [custom] strings as values.",
|
2010-12-03 22:59:16 +00:00
|
|
|
hfinfo->abbrev);
|
|
|
|
}
|
2009-07-03 01:11:23 +00:00
|
|
|
else {
|
2012-06-03 09:26:15 +00:00
|
|
|
const value_string *vals = (const value_string *)hfinfo->strings;
|
2010-04-27 10:32:34 +00:00
|
|
|
if (hfinfo->display & BASE_EXT_STRING)
|
2012-04-10 10:20:20 +00:00
|
|
|
vals = VALUE_STRING_EXT_VS_P((const value_string_ext *) vals);
|
2010-04-27 10:32:34 +00:00
|
|
|
|
2009-07-03 01:11:23 +00:00
|
|
|
while (vals->strptr != NULL) {
|
|
|
|
if (g_ascii_strcasecmp(s, vals->strptr) == 0) {
|
|
|
|
return mk_uint32_fvalue(vals->value);
|
|
|
|
}
|
|
|
|
vals++;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" cannot be found among the possible values for %s.",
|
2009-07-03 01:11:23 +00:00
|
|
|
s, hfinfo->abbrev);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2009-07-03 01:11:23 +00:00
|
|
|
return NULL;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
is_bytes_type(enum ftenum type)
|
|
|
|
{
|
|
|
|
switch(type) {
|
2012-08-02 16:54:43 +00:00
|
|
|
case FT_AX25:
|
2013-07-28 00:07:49 +00:00
|
|
|
case FT_VINES:
|
2014-12-24 05:06:35 +00:00
|
|
|
case FT_FCWWN:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_ETHER:
|
|
|
|
case FT_BYTES:
|
2002-05-09 23:50:34 +00:00
|
|
|
case FT_UINT_BYTES:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_IPv6:
|
2005-07-04 13:04:53 +00:00
|
|
|
case FT_GUID:
|
2005-12-02 13:16:58 +00:00
|
|
|
case FT_OID:
|
2013-10-06 02:31:10 +00:00
|
|
|
case FT_REL_OID:
|
2013-12-23 17:57:57 +00:00
|
|
|
case FT_SYSTEM_ID:
|
2001-02-01 20:21:25 +00:00
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
case FT_NONE:
|
|
|
|
case FT_PROTOCOL:
|
2002-08-24 19:45:28 +00:00
|
|
|
case FT_FLOAT:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_DOUBLE:
|
2015-09-06 17:01:47 +00:00
|
|
|
case FT_IEEE_11073_SFLOAT:
|
|
|
|
case FT_IEEE_11073_FLOAT:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_ABSOLUTE_TIME:
|
|
|
|
case FT_RELATIVE_TIME:
|
|
|
|
case FT_IPv4:
|
|
|
|
case FT_IPXNET:
|
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
|
|
|
case FT_UINT_STRING:
|
2014-04-12 22:26:34 +00:00
|
|
|
case FT_STRINGZPAD:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_BOOLEAN:
|
2002-12-19 02:58:53 +00:00
|
|
|
case FT_FRAMENUM:
|
2016-09-19 01:48:50 +00:00
|
|
|
case FT_CHAR:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
2014-12-17 20:19:20 +00:00
|
|
|
case FT_UINT40:
|
|
|
|
case FT_UINT48:
|
|
|
|
case FT_UINT56:
|
2001-11-02 10:09:51 +00:00
|
|
|
case FT_UINT64:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_INT8:
|
|
|
|
case FT_INT16:
|
|
|
|
case FT_INT24:
|
|
|
|
case FT_INT32:
|
2014-12-17 20:19:20 +00:00
|
|
|
case FT_INT40:
|
|
|
|
case FT_INT48:
|
|
|
|
case FT_INT56:
|
2001-11-02 10:09:51 +00:00
|
|
|
case FT_INT64:
|
2003-12-09 23:02:40 +00:00
|
|
|
case FT_PCRE:
|
2011-05-08 10:23:53 +00:00
|
|
|
case FT_EUI64:
|
2001-02-01 20:21:25 +00:00
|
|
|
return FALSE;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert_not_reached();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2004-02-11 21:20:52 +00:00
|
|
|
/* Check the semantics of an existence test. */
|
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_exists(dfwork_t *dfw, stnode_t *st_arg1)
|
2004-02-11 21:20:52 +00:00
|
|
|
{
|
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
DebugLog((" 4 check_exists() [%u]\n", i++));
|
|
|
|
switch (stnode_type_id(st_arg1)) {
|
|
|
|
case STTYPE_FIELD:
|
|
|
|
/* This is OK */
|
|
|
|
break;
|
|
|
|
case STTYPE_STRING:
|
2016-09-19 01:48:50 +00:00
|
|
|
case STTYPE_CHARCONST:
|
2004-02-11 21:20:52 +00:00
|
|
|
case STTYPE_UNPARSED:
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" is neither a field nor a protocol name.",
|
2014-07-06 13:34:38 +00:00
|
|
|
(char *)stnode_data(st_arg1));
|
2004-02-11 21:20:52 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case STTYPE_RANGE:
|
|
|
|
/*
|
|
|
|
* XXX - why not? Shouldn't "eth[3:2]" mean
|
|
|
|
* "check whether the 'eth' field is present and
|
|
|
|
* has at least 2 bytes starting at an offset of
|
|
|
|
* 3"?
|
|
|
|
*/
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "You cannot test whether a range is present.");
|
2004-02-11 21:20:52 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
break;
|
|
|
|
|
2006-05-02 14:26:17 +00:00
|
|
|
case STTYPE_FUNCTION:
|
2011-04-27 04:24:44 +00:00
|
|
|
/* XXX - Maybe we should change functions so they can return fields,
|
|
|
|
* in which case the 'exist' should be fine. */
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "You cannot test whether a function is present.");
|
2006-05-02 14:26:17 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
break;
|
|
|
|
|
2004-02-11 21:20:52 +00:00
|
|
|
case STTYPE_UNINITIALIZED:
|
|
|
|
case STTYPE_TEST:
|
|
|
|
case STTYPE_INTEGER:
|
|
|
|
case STTYPE_FVALUE:
|
2015-08-19 03:03:41 +00:00
|
|
|
case STTYPE_SET:
|
2004-02-11 21:20:52 +00:00
|
|
|
case STTYPE_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-06-03 07:33:46 +00:00
|
|
|
struct check_drange_sanity_args {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfwork_t *dfw;
|
2004-06-03 07:33:46 +00:00
|
|
|
stnode_t *st;
|
|
|
|
gboolean err;
|
|
|
|
};
|
|
|
|
|
2013-07-27 17:17:15 +00:00
|
|
|
/* Q: Where are sttype_range_drange() and sttype_range_entity() defined?
|
2004-06-03 07:33:46 +00:00
|
|
|
*
|
|
|
|
* A: Those functions are defined by macros in epan/dfilter/sttype-range.h
|
|
|
|
*
|
|
|
|
* The macro which creates them, STTYPE_ACCESSOR, is defined in
|
|
|
|
* epan/dfilter/syntax-tree.h.
|
|
|
|
*
|
2019-07-26 18:43:17 +00:00
|
|
|
* From https://www.wireshark.org/lists/ethereal-dev/200308/msg00070.html
|
2004-06-03 07:33:46 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_drange_node_sanity(gpointer data, gpointer user_data)
|
|
|
|
{
|
2012-06-03 09:26:15 +00:00
|
|
|
drange_node* drnode = (drange_node*)data;
|
|
|
|
struct check_drange_sanity_args *args = (struct check_drange_sanity_args*)user_data;
|
2004-06-03 07:33:46 +00:00
|
|
|
gint start_offset, end_offset, length;
|
2013-07-27 17:17:15 +00:00
|
|
|
stnode_t *entity;
|
2004-06-03 07:33:46 +00:00
|
|
|
header_field_info *hfinfo;
|
|
|
|
|
|
|
|
switch (drange_node_get_ending(drnode)) {
|
|
|
|
|
2010-01-19 19:37:03 +00:00
|
|
|
case DRANGE_NODE_END_T_LENGTH:
|
2004-06-03 07:33:46 +00:00
|
|
|
length = drange_node_get_length(drnode);
|
|
|
|
if (length <= 0) {
|
|
|
|
if (!args->err) {
|
|
|
|
args->err = TRUE;
|
|
|
|
start_offset = drange_node_get_start_offset(drnode);
|
2013-07-27 17:17:15 +00:00
|
|
|
entity = sttype_range_entity(args->st);
|
|
|
|
if (entity && stnode_type_id(entity) == STTYPE_FIELD) {
|
2013-07-27 18:55:05 +00:00
|
|
|
hfinfo = (header_field_info *)stnode_data(entity);
|
2013-07-27 17:17:15 +00:00
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(args->dfw, "Range %d:%d specified for \"%s\" isn't valid, "
|
2013-07-27 17:17:15 +00:00
|
|
|
"as length %d isn't positive",
|
|
|
|
start_offset, length,
|
|
|
|
hfinfo->abbrev,
|
|
|
|
length);
|
|
|
|
} else
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(args->dfw, "Range %d:%d isn't valid, "
|
2013-07-27 17:17:15 +00:00
|
|
|
"as length %d isn't positive",
|
|
|
|
start_offset, length,
|
|
|
|
length);
|
2004-06-03 07:33:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2010-01-19 19:37:03 +00:00
|
|
|
case DRANGE_NODE_END_T_OFFSET:
|
2004-06-03 07:33:46 +00:00
|
|
|
/*
|
|
|
|
* Make sure the start offset isn't beyond the end
|
|
|
|
* offset. This applies to negative offsets too.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* XXX - [-ve - +ve] is probably pathological, but isn't
|
|
|
|
* disallowed.
|
|
|
|
* [+ve - -ve] is probably pathological too, and happens to be
|
|
|
|
* disallowed.
|
|
|
|
*/
|
|
|
|
start_offset = drange_node_get_start_offset(drnode);
|
|
|
|
end_offset = drange_node_get_end_offset(drnode);
|
|
|
|
if (start_offset > end_offset) {
|
|
|
|
if (!args->err) {
|
|
|
|
args->err = TRUE;
|
2013-07-27 17:17:15 +00:00
|
|
|
entity = sttype_range_entity(args->st);
|
|
|
|
if (entity && stnode_type_id(entity) == STTYPE_FIELD) {
|
2013-07-27 18:55:05 +00:00
|
|
|
hfinfo = (header_field_info *)stnode_data(entity);
|
2013-07-27 17:17:15 +00:00
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(args->dfw, "Range %d-%d specified for \"%s\" isn't valid, "
|
2013-07-27 17:17:15 +00:00
|
|
|
"as %d is greater than %d",
|
|
|
|
start_offset, end_offset,
|
|
|
|
hfinfo->abbrev,
|
|
|
|
start_offset, end_offset);
|
|
|
|
|
|
|
|
} else
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(args->dfw, "Range %d-%d isn't valid, "
|
2013-07-27 17:17:15 +00:00
|
|
|
"as %d is greater than %d",
|
|
|
|
start_offset, end_offset,
|
|
|
|
start_offset, end_offset);
|
2004-06-03 07:33:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2010-01-19 19:37:03 +00:00
|
|
|
case DRANGE_NODE_END_T_TO_THE_END:
|
2004-06-03 07:33:46 +00:00
|
|
|
break;
|
|
|
|
|
2010-01-19 19:37:03 +00:00
|
|
|
case DRANGE_NODE_END_T_UNINITIALIZED:
|
2004-06-03 07:33:46 +00:00
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfwork_t *dfw, stnode_t *st)
|
2004-06-03 07:33:46 +00:00
|
|
|
{
|
|
|
|
struct check_drange_sanity_args args;
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
args.dfw = dfw;
|
2004-06-03 07:33:46 +00:00
|
|
|
args.st = st;
|
|
|
|
args.err = FALSE;
|
|
|
|
|
|
|
|
drange_foreach_drange_node(sttype_range_drange(st),
|
|
|
|
check_drange_node_sanity, &args);
|
|
|
|
|
|
|
|
if (args.err) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-28 08:41:26 +00:00
|
|
|
static stnode_t *
|
|
|
|
convert_to_bytes(stnode_t *arg)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
|
|
|
drange_node *rn;
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_RANGE, NULL);
|
|
|
|
|
|
|
|
rn = drange_node_new();
|
|
|
|
drange_node_set_start_offset(rn, 0);
|
|
|
|
drange_node_set_to_the_end(rn);
|
|
|
|
/* new_st is owner of arg in this step */
|
|
|
|
sttype_range_set1(new_st, arg, rn);
|
|
|
|
|
|
|
|
return new_st;
|
|
|
|
}
|
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfwork_t *dfw, stnode_t *st_node)
|
2009-05-31 19:46:31 +00:00
|
|
|
{
|
|
|
|
df_func_def_t *funcdef;
|
|
|
|
GSList *params;
|
|
|
|
guint iparam;
|
2009-12-18 01:15:08 +00:00
|
|
|
guint nparams;
|
2009-05-31 19:46:31 +00:00
|
|
|
|
|
|
|
funcdef = sttype_function_funcdef(st_node);
|
|
|
|
params = sttype_function_params(st_node);
|
|
|
|
nparams = g_slist_length(params);
|
|
|
|
|
|
|
|
if (nparams < funcdef->min_nargs) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Function %s needs at least %u arguments.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, funcdef->min_nargs);
|
|
|
|
THROW(TypeError);
|
|
|
|
} else if (nparams > funcdef->max_nargs) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Function %s can only accept %u arguments.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, funcdef->max_nargs);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
iparam = 0;
|
|
|
|
while (params) {
|
2015-01-18 10:22:19 +00:00
|
|
|
params->data = check_param_entity(dfw, (stnode_t *)params->data);
|
|
|
|
funcdef->semcheck_param_function(dfw, iparam, (stnode_t *)params->data);
|
2009-05-31 19:46:31 +00:00
|
|
|
params = params->next;
|
|
|
|
iparam++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-19 01:48:50 +00:00
|
|
|
/* Convert a character constant to a 1-byte BYTE_STRING containing the
|
|
|
|
* character. */
|
|
|
|
static fvalue_t *
|
2018-06-18 00:30:01 +00:00
|
|
|
dfilter_fvalue_from_charconst_string(dfwork_t *dfw, ftenum_t ftype, char *s, gboolean allow_partial_value)
|
2016-09-19 01:48:50 +00:00
|
|
|
{
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
|
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_CHAR, s, allow_partial_value);
|
|
|
|
if (fvalue) {
|
|
|
|
char *temp_string;
|
|
|
|
/* It's valid. Create a 1-byte BYTE_STRING from its value. */
|
|
|
|
temp_string = g_strdup_printf("%02x", fvalue->value.uinteger);
|
|
|
|
FVALUE_FREE(fvalue);
|
2018-06-17 22:01:24 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype, temp_string, allow_partial_value);
|
2016-09-19 01:48:50 +00:00
|
|
|
g_free(temp_string);
|
|
|
|
}
|
|
|
|
return (fvalue);
|
|
|
|
}
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* If the LHS of a relation test is a FIELD, run some checks
|
|
|
|
* and possibly some modifications of syntax tree nodes. */
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_FIELD(dfwork_t *dfw, const char *relation_string,
|
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value,
|
2003-07-25 03:44:05 +00:00
|
|
|
stnode_t *st_node, stnode_t *st_arg1, stnode_t *st_arg2)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
2011-04-27 04:24:44 +00:00
|
|
|
sttype_id_t type2;
|
2001-02-01 20:21:25 +00:00
|
|
|
header_field_info *hfinfo1, *hfinfo2;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
2001-02-01 20:21:25 +00:00
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2012-06-03 09:26:15 +00:00
|
|
|
hfinfo1 = (header_field_info*)stnode_data(st_arg1);
|
2001-02-27 19:23:30 +00:00
|
|
|
ftype1 = hfinfo1->type;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2015-08-19 03:03:41 +00:00
|
|
|
if (stnode_type_id(st_node) == STTYPE_TEST) {
|
|
|
|
DebugLog((" 5 check_relation_LHS_FIELD(%s)\n", relation_string));
|
|
|
|
} else {
|
|
|
|
DebugLog((" 6 check_relation_LHS_FIELD(%s)\n", relation_string));
|
|
|
|
}
|
2004-01-01 16:59:20 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!can_func(ftype1)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s (type=%s) cannot participate in '%s' comparison.",
|
2003-07-25 03:44:05 +00:00
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1),
|
|
|
|
relation_string);
|
2001-02-27 19:23:30 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
2012-06-03 09:26:15 +00:00
|
|
|
hfinfo2 = (header_field_info*)stnode_data(st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
ftype2 = hfinfo2->type;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s and %s are not of compatible types.",
|
2001-02-27 19:23:30 +00:00
|
|
|
hfinfo1->abbrev, hfinfo2->abbrev);
|
|
|
|
THROW(TypeError);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
/* Do this check even though you'd think that if
|
|
|
|
* they're compatible, then can_func() would pass. */
|
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s (type=%s) cannot participate in specified comparison.",
|
2001-02-27 19:23:30 +00:00
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
}
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_STRING || type2 == STTYPE_UNPARSED ||
|
|
|
|
type2 == STTYPE_CHARCONST) {
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char *)stnode_data(st_arg2);
|
2003-12-09 23:02:40 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
2014-12-09 17:55:44 +00:00
|
|
|
if (type2 == STTYPE_STRING)
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_PCRE, s);
|
2014-12-09 17:55:44 +00:00
|
|
|
else
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_PCRE, s, FALSE);
|
2003-12-09 23:02:40 +00:00
|
|
|
} else {
|
2014-12-09 17:55:44 +00:00
|
|
|
/* Skip incompatible fields */
|
|
|
|
while (hfinfo1->same_name_prev_id != -1 &&
|
|
|
|
((type2 == STTYPE_STRING && ftype1 != FT_STRING && ftype1!= FT_STRINGZ) ||
|
|
|
|
(type2 != STTYPE_STRING && (ftype1 == FT_STRING || ftype1== FT_STRINGZ)))) {
|
|
|
|
hfinfo1 = proto_registrar_get_nth(hfinfo1->same_name_prev_id);
|
|
|
|
ftype1 = hfinfo1->type;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type2 == STTYPE_STRING)
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype1, s);
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_CHARCONST &&
|
|
|
|
strcmp(relation_string, "contains") == 0) {
|
2018-06-17 22:01:24 +00:00
|
|
|
/* The RHS should be the same type as the LHS,
|
|
|
|
* but a character is just a one-byte byte
|
|
|
|
* string. */
|
2018-06-18 00:30:01 +00:00
|
|
|
fvalue = dfilter_fvalue_from_charconst_string(dfw, ftype1, s, allow_partial_value);
|
2016-09-19 01:48:50 +00:00
|
|
|
} else
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype1, s, allow_partial_value);
|
2014-12-09 17:55:44 +00:00
|
|
|
|
2016-09-19 01:48:50 +00:00
|
|
|
/*
|
|
|
|
* If this is a character constant, just report the
|
|
|
|
* error, don't try to treat it as a string from
|
|
|
|
* a value_string table.
|
|
|
|
*/
|
|
|
|
if (!fvalue && type2 != STTYPE_CHARCONST) {
|
2003-12-09 23:02:40 +00:00
|
|
|
/* check value_string */
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = mk_fvalue_from_val_string(dfw, hfinfo1, s);
|
2017-05-04 15:57:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Ignore previous errors if this can be mapped
|
|
|
|
* to an item from value_string.
|
|
|
|
*/
|
|
|
|
if (fvalue && dfw->error_message) {
|
|
|
|
g_free(dfw->error_message);
|
|
|
|
dfw->error_message = NULL;
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
|
2003-12-09 23:02:40 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
2015-08-19 03:03:41 +00:00
|
|
|
if (stnode_type_id(st_node) == STTYPE_TEST) {
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
} else {
|
2018-04-14 16:07:22 +00:00
|
|
|
/* Replace STTYPE_UNPARSED element by resolved value. */
|
2015-08-19 03:03:41 +00:00
|
|
|
sttype_set_replace_element(st_node, st_arg2, new_st);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfw, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!is_bytes_type(ftype1)) {
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2001-02-27 19:23:30 +00:00
|
|
|
hfinfo1->abbrev,
|
|
|
|
ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert entire field to bytes */
|
2013-07-28 08:41:26 +00:00
|
|
|
new_st = convert_to_bytes(st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2011-04-27 04:24:44 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s (type=%s) and return value of %s() (type=%s) are not of compatible types.",
|
2009-12-18 01:15:08 +00:00
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1),
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "return value of %s() (type=%s) cannot participate in specified comparison.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfw, st_arg2);
|
2011-04-27 04:24:44 +00:00
|
|
|
}
|
2015-08-19 03:03:41 +00:00
|
|
|
else if (type2 == STTYPE_SET) {
|
|
|
|
GSList *nodelist;
|
|
|
|
/* A set should only ever appear on RHS of 'in' operation */
|
|
|
|
if (strcmp(relation_string, "in") != 0) {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2018-04-14 16:07:22 +00:00
|
|
|
/* Attempt to interpret one element of the set at a time. Each
|
|
|
|
* element is represented by two items in the list, the element
|
|
|
|
* value and NULL. Both will be replaced by a lower and upper
|
|
|
|
* value if the element is a range. */
|
2015-08-19 03:03:41 +00:00
|
|
|
nodelist = (GSList*)stnode_data(st_arg2);
|
|
|
|
while (nodelist) {
|
|
|
|
stnode_t *node = (stnode_t*)nodelist->data;
|
|
|
|
/* Don't let a range on the RHS affect the LHS field. */
|
|
|
|
if (stnode_type_id(node) == STTYPE_RANGE) {
|
|
|
|
dfilter_fail(dfw, "A range may not appear inside a set.");
|
|
|
|
THROW(TypeError);
|
|
|
|
break;
|
|
|
|
}
|
2018-04-14 16:07:22 +00:00
|
|
|
|
|
|
|
nodelist = g_slist_next(nodelist);
|
|
|
|
g_assert(nodelist);
|
|
|
|
stnode_t *node_right = (stnode_t *)nodelist->data;
|
|
|
|
if (node_right) {
|
|
|
|
/* range type, check if comparison is possible. */
|
|
|
|
if (!ftype_can_ge(ftype1)) {
|
|
|
|
dfilter_fail(dfw, "%s (type=%s) cannot participate in '%s' comparison.",
|
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1),
|
|
|
|
">=");
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
check_relation_LHS_FIELD(dfw, ">=", ftype_can_ge,
|
|
|
|
allow_partial_value, st_arg2, st_arg1, node);
|
|
|
|
check_relation_LHS_FIELD(dfw, "<=", ftype_can_le,
|
|
|
|
allow_partial_value, st_arg2, st_arg1, node_right);
|
|
|
|
} else {
|
|
|
|
check_relation_LHS_FIELD(dfw, "==", can_func,
|
|
|
|
allow_partial_value, st_arg2, st_arg1, node);
|
|
|
|
}
|
2015-08-19 03:03:41 +00:00
|
|
|
nodelist = g_slist_next(nodelist);
|
|
|
|
}
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_STRING(dfwork_t *dfw, const char* relation_string,
|
2009-06-01 18:24:42 +00:00
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value _U_,
|
2003-08-27 15:23:11 +00:00
|
|
|
stnode_t *st_node,
|
2001-02-27 19:23:30 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
2011-04-27 04:24:44 +00:00
|
|
|
sttype_id_t type2;
|
2001-02-27 19:23:30 +00:00
|
|
|
header_field_info *hfinfo2;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
2001-02-27 19:23:30 +00:00
|
|
|
ftenum_t ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_STRING()\n"));
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
2012-06-03 09:26:15 +00:00
|
|
|
hfinfo2 = (header_field_info*)stnode_data(st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
ftype2 = hfinfo2->type;
|
|
|
|
|
2004-02-22 03:04:41 +00:00
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s (type=%s) cannot participate in '%s' comparison.",
|
2004-02-22 03:04:41 +00:00
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2),
|
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg1);
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype2, s);
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
/* check value_string */
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = mk_fvalue_from_val_string(dfw, hfinfo2, s);
|
2001-02-01 20:21:25 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_STRING || type2 == STTYPE_UNPARSED ||
|
|
|
|
type2 == STTYPE_CHARCONST) {
|
2001-02-27 19:23:30 +00:00
|
|
|
/* Well now that's silly... */
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Neither \"%s\" nor \"%s\" are field or protocol names.",
|
2014-07-06 13:34:38 +00:00
|
|
|
(char *)stnode_data(st_arg1),
|
|
|
|
(char *)stnode_data(st_arg2));
|
2001-02-27 19:23:30 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfw, st_arg2);
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg1);
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_BYTES, s);
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!fvalue) {
|
2001-02-01 20:21:25 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
|
|
|
funcdef = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Return value of function %s (type=%s) cannot participate in '%s' comparison.",
|
2009-12-18 01:15:08 +00:00
|
|
|
funcdef->name, ftype_pretty_name(ftype2),
|
2009-05-31 19:46:31 +00:00
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2012-06-03 20:59:41 +00:00
|
|
|
s = (char*)stnode_data(st_arg1);
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype2, s);
|
2009-05-31 19:46:31 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfw, st_arg2);
|
2009-05-31 19:46:31 +00:00
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2015-08-19 03:03:41 +00:00
|
|
|
else if (type2 == STTYPE_SET) {
|
|
|
|
dfilter_fail(dfw, "Only a field may be tested for membership in a set.");
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_UNPARSED(dfwork_t *dfw, const char* relation_string,
|
2004-02-22 03:04:41 +00:00
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value,
|
2003-08-27 15:23:11 +00:00
|
|
|
stnode_t *st_node,
|
2003-07-25 03:44:05 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
2011-04-27 04:24:44 +00:00
|
|
|
sttype_id_t type2;
|
2003-07-25 03:44:05 +00:00
|
|
|
header_field_info *hfinfo2;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
2003-07-25 03:44:05 +00:00
|
|
|
ftenum_t ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_UNPARSED()\n"));
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
2012-06-03 09:26:15 +00:00
|
|
|
hfinfo2 = (header_field_info*)stnode_data(st_arg2);
|
2003-07-25 03:44:05 +00:00
|
|
|
ftype2 = hfinfo2->type;
|
|
|
|
|
2004-02-22 03:04:41 +00:00
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s (type=%s) cannot participate in '%s' comparison.",
|
2004-02-22 03:04:41 +00:00
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2),
|
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg1);
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype2, s, allow_partial_value);
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
/* check value_string */
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = mk_fvalue_from_val_string(dfw, hfinfo2, s);
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_STRING || type2 == STTYPE_UNPARSED ||
|
|
|
|
type2 == STTYPE_CHARCONST) {
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Well now that's silly... */
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Neither \"%s\" nor \"%s\" are field or protocol names.",
|
2014-07-06 13:34:38 +00:00
|
|
|
(char *)stnode_data(st_arg1),
|
|
|
|
(char *)stnode_data(st_arg2));
|
2003-07-25 03:44:05 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfw, st_arg2);
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg1);
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_BYTES, s, allow_partial_value);
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
|
|
|
funcdef = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "return value of function %s() (type=%s) cannot participate in '%s' comparison.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, ftype_pretty_name(ftype2), relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg1);
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype2, s, allow_partial_value);
|
2009-12-18 01:15:08 +00:00
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfw, st_arg2);
|
2009-05-31 19:46:31 +00:00
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2015-08-19 03:03:41 +00:00
|
|
|
else if (type2 == STTYPE_SET) {
|
|
|
|
dfilter_fail(dfw, "Only a field may be tested for membership in a set.");
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_RANGE(dfwork_t *dfw, const char *relation_string,
|
|
|
|
FtypeCanFunc can_func _U_,
|
2004-01-01 16:59:20 +00:00
|
|
|
gboolean allow_partial_value,
|
2003-08-27 15:23:11 +00:00
|
|
|
stnode_t *st_node,
|
2001-02-27 19:23:30 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
2011-04-27 04:24:44 +00:00
|
|
|
sttype_id_t type2;
|
2013-07-27 17:17:15 +00:00
|
|
|
stnode_t *entity1;
|
2001-02-27 19:23:30 +00:00
|
|
|
header_field_info *hfinfo1, *hfinfo2;
|
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
2015-02-13 19:02:43 +00:00
|
|
|
int len_range;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(%s)\n", relation_string));
|
|
|
|
|
2013-07-27 17:17:15 +00:00
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
entity1 = sttype_range_entity(st_arg1);
|
|
|
|
if (entity1 && stnode_type_id(entity1) == STTYPE_FIELD) {
|
2013-07-27 18:55:05 +00:00
|
|
|
hfinfo1 = (header_field_info *)stnode_data(entity1);
|
2013-07-27 17:17:15 +00:00
|
|
|
ftype1 = hfinfo1->type;
|
|
|
|
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" is a %s and cannot be sliced into a sequence of bytes.",
|
2013-07-27 17:17:15 +00:00
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2013-07-27 19:14:34 +00:00
|
|
|
} else if (entity1 && stnode_type_id(entity1) == STTYPE_FUNCTION) {
|
|
|
|
df_func_def_t *funcdef = sttype_function_funcdef(entity1);
|
|
|
|
ftype1 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Return value of function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2013-07-27 19:14:34 +00:00
|
|
|
funcdef->name, ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfw, entity1);
|
2013-07-27 19:14:34 +00:00
|
|
|
|
2013-07-27 17:17:15 +00:00
|
|
|
} else {
|
2016-02-12 01:26:20 +00:00
|
|
|
if (entity1 == NULL) {
|
|
|
|
dfilter_fail(dfw, "Range is not supported, details: " G_STRLOC " entity: NULL");
|
|
|
|
} else {
|
|
|
|
dfilter_fail(dfw, "Range is not supported, details: " G_STRLOC " entity: %p of type %d",
|
|
|
|
(void *)entity1, stnode_type_id(entity1));
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfw, st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_FIELD)\n"));
|
2012-06-03 09:26:15 +00:00
|
|
|
hfinfo2 = (header_field_info*)stnode_data(st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
ftype2 = hfinfo2->type;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!is_bytes_type(ftype2)) {
|
|
|
|
if (!ftype_can_slice(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "\"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2001-02-27 19:23:30 +00:00
|
|
|
hfinfo2->abbrev,
|
|
|
|
ftype_pretty_name(ftype2));
|
2001-02-01 20:21:25 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
|
|
|
|
/* Convert entire field to bytes */
|
2013-07-28 08:41:26 +00:00
|
|
|
new_st = convert_to_bytes(st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_STRING) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_STRING)\n"));
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg2);
|
2004-01-01 16:59:20 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_PCRE, s);
|
2004-01-01 16:59:20 +00:00
|
|
|
} else {
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_BYTES, s);
|
2004-01-01 16:59:20 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!fvalue) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_STRING): Could not convert from string!\n"));
|
2001-02-27 19:23:30 +00:00
|
|
|
THROW(TypeError);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_UNPARSED)\n"));
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg2);
|
2015-02-13 19:02:43 +00:00
|
|
|
len_range = drange_get_total_length(sttype_range_drange(st_arg1));
|
2004-01-01 16:59:20 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_PCRE, s, FALSE);
|
2004-01-01 16:59:20 +00:00
|
|
|
}
|
2012-02-29 05:58:45 +00:00
|
|
|
|
2015-02-13 19:02:43 +00:00
|
|
|
/* The RHS should be FT_BYTES. However, there is a special case where
|
|
|
|
* the range slice on the LHS is one byte long. In that case, it is natural
|
|
|
|
* for the user to specify a normal hex integer on the RHS, with the "0x"
|
|
|
|
* notation, as in "slice[0] == 0x10". We can't allow this for any
|
|
|
|
* slices that are longer than one byte, because then we'd have to know
|
|
|
|
* which endianness the byte string should be in. */
|
|
|
|
else if (len_range == 1 && strlen(s) == 4 && strncmp(s, "0x", 2) == 0) {
|
|
|
|
/* Even if the RHS string starts with "0x", it still could fail to
|
|
|
|
* be an integer. Try converting it here. */
|
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_UINT8, s, allow_partial_value);
|
|
|
|
if (fvalue) {
|
|
|
|
FVALUE_FREE(fvalue);
|
|
|
|
/* The value doees indeed fit into 8 bits. Create a BYTE_STRING
|
|
|
|
* from it. Since we know that the last 2 characters are a valid
|
|
|
|
* hex string, just use those directly. */
|
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_BYTES, s+2, allow_partial_value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_BYTES, s, allow_partial_value);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_UNPARSED): Could not convert from string!\n"));
|
2003-07-25 03:44:05 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_CHARCONST) {
|
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_CHARCONST)\n"));
|
|
|
|
s = (char*)stnode_data(st_arg2);
|
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_PCRE, s, FALSE);
|
2016-10-24 08:15:59 +00:00
|
|
|
} else {
|
|
|
|
/* The RHS should be FT_BYTES, but a character is just a
|
|
|
|
* one-byte byte string. */
|
2018-06-18 00:30:01 +00:00
|
|
|
fvalue = dfilter_fvalue_from_charconst_string(dfw, FT_BYTES, s, allow_partial_value);
|
2016-09-19 01:48:50 +00:00
|
|
|
}
|
|
|
|
if (!fvalue) {
|
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_UNPARSED): Could not convert from string!\n"));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_RANGE)\n"));
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfw, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
2013-07-27 19:14:34 +00:00
|
|
|
df_func_def_t *funcdef = sttype_function_funcdef(st_arg2);
|
2009-05-31 19:46:31 +00:00
|
|
|
ftype2 = funcdef->retval_ftype;
|
2009-12-18 01:15:08 +00:00
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
if (!is_bytes_type(ftype2)) {
|
|
|
|
if (!ftype_can_slice(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Return value of function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name,
|
|
|
|
ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2013-07-28 08:41:26 +00:00
|
|
|
/* Convert function result to bytes */
|
|
|
|
new_st = convert_to_bytes(st_arg2);
|
2013-07-27 18:55:05 +00:00
|
|
|
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfw, st_arg2);
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
2015-08-19 03:03:41 +00:00
|
|
|
else if (type2 == STTYPE_SET) {
|
|
|
|
dfilter_fail(dfw, "Only a field may be tested for membership in a set.");
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-02 14:26:17 +00:00
|
|
|
static stnode_t*
|
2015-01-18 10:22:19 +00:00
|
|
|
check_param_entity(dfwork_t *dfw, stnode_t *st_node)
|
2006-05-02 14:26:17 +00:00
|
|
|
{
|
|
|
|
sttype_id_t e_type;
|
|
|
|
stnode_t *new_st;
|
|
|
|
fvalue_t *fvalue;
|
2011-04-27 04:24:44 +00:00
|
|
|
char *s;
|
2006-05-02 14:26:17 +00:00
|
|
|
|
|
|
|
e_type = stnode_type_id(st_node);
|
2011-04-27 04:24:44 +00:00
|
|
|
/* If there's an unparsed string, change it to an FT_STRING */
|
2016-09-19 01:48:50 +00:00
|
|
|
if (e_type == STTYPE_UNPARSED || e_type == STTYPE_CHARCONST) {
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_node);
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_STRING, s, FALSE);
|
2006-05-02 14:26:17 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
stnode_free(st_node);
|
2011-04-27 04:24:44 +00:00
|
|
|
return new_st;
|
|
|
|
}
|
|
|
|
return st_node;
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* If the LHS of a relation test is a FUNCTION, run some checks
|
|
|
|
* and possibly some modifications of syntax tree nodes. */
|
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_FUNCTION(dfwork_t *dfw, const char *relation_string,
|
|
|
|
FtypeCanFunc can_func,
|
2006-05-02 14:26:17 +00:00
|
|
|
gboolean allow_partial_value,
|
|
|
|
stnode_t *st_node, stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
|
|
|
sttype_id_t type2;
|
|
|
|
header_field_info *hfinfo2;
|
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
|
|
|
df_func_def_t *funcdef2;
|
2011-04-04 15:31:33 +00:00
|
|
|
/* GSList *params; */
|
2006-05-02 14:26:17 +00:00
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfw, st_arg1);
|
2006-05-02 14:26:17 +00:00
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef = sttype_function_funcdef(st_arg1);
|
2006-05-02 14:26:17 +00:00
|
|
|
ftype1 = funcdef->retval_ftype;
|
|
|
|
|
2011-04-04 15:31:33 +00:00
|
|
|
/* params = */sttype_function_params(st_arg1); /* XXX: is this done for the side-effect ? */
|
2006-05-02 14:26:17 +00:00
|
|
|
|
|
|
|
DebugLog((" 5 check_relation_LHS_FUNCTION(%s)\n", relation_string));
|
|
|
|
|
|
|
|
if (!can_func(ftype1)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Function %s (type=%s) cannot participate in '%s' comparison.",
|
2006-05-02 14:26:17 +00:00
|
|
|
funcdef->name, ftype_pretty_name(ftype1),
|
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type2 == STTYPE_FIELD) {
|
2012-06-03 09:26:15 +00:00
|
|
|
hfinfo2 = (header_field_info*)stnode_data(st_arg2);
|
2006-05-02 14:26:17 +00:00
|
|
|
ftype2 = hfinfo2->type;
|
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Function %s and %s are not of compatible types.",
|
2006-05-02 14:26:17 +00:00
|
|
|
funcdef->name, hfinfo2->abbrev);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
/* Do this check even though you'd think that if
|
|
|
|
* they're compatible, then can_func() would pass. */
|
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "%s (type=%s) cannot participate in specified comparison.",
|
2006-05-02 14:26:17 +00:00
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_STRING) {
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg2);
|
2006-05-02 14:26:17 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_PCRE, s);
|
2006-05-02 14:26:17 +00:00
|
|
|
} else {
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype1, s);
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED || type2 == STTYPE_CHARCONST) {
|
2012-06-03 09:26:15 +00:00
|
|
|
s = (char*)stnode_data(st_arg2);
|
2006-05-02 14:26:17 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_PCRE, s, FALSE);
|
2006-05-02 14:26:17 +00:00
|
|
|
} else {
|
2015-01-18 10:22:19 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype1, s, allow_partial_value);
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfw, st_arg2);
|
2006-05-02 14:26:17 +00:00
|
|
|
if (!is_bytes_type(ftype1)) {
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2006-05-02 14:26:17 +00:00
|
|
|
funcdef->name,
|
|
|
|
ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2013-07-28 08:41:26 +00:00
|
|
|
/* Convert function result to bytes */
|
|
|
|
new_st = convert_to_bytes(st_arg1);
|
2006-05-02 14:26:17 +00:00
|
|
|
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
}
|
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
|
|
|
funcdef2 = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef2->retval_ftype;
|
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Return values of function %s (type=%s) and function %s (type=%s) are not of compatible types.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, ftype_pretty_name(ftype1), funcdef2->name, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do this check even though you'd think that if
|
|
|
|
* they're compatible, then can_func() would pass. */
|
|
|
|
if (!can_func(ftype2)) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Return value of %s (type=%s) cannot participate in specified comparison.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef2->name, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_function(dfw, st_arg2);
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
2015-08-19 03:03:41 +00:00
|
|
|
else if (type2 == STTYPE_SET) {
|
|
|
|
dfilter_fail(dfw, "Only a field may be tested for membership in a set.");
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2006-05-02 14:26:17 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the semantics of any relational test. */
|
2001-02-27 19:23:30 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfwork_t *dfw, const char *relation_string,
|
|
|
|
gboolean allow_partial_value,
|
2003-08-27 15:23:11 +00:00
|
|
|
FtypeCanFunc can_func, stnode_t *st_node,
|
2001-02-27 19:23:30 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
2004-05-09 08:17:32 +00:00
|
|
|
header_field_info *hfinfo;
|
2003-12-09 23:02:40 +00:00
|
|
|
|
|
|
|
DebugLog((" 4 check_relation(\"%s\") [%u]\n", relation_string, i++));
|
2004-05-09 08:17:32 +00:00
|
|
|
|
|
|
|
/* Protocol can only be on LHS (for "contains" or "matches" operators).
|
|
|
|
* Check to see if protocol is on RHS. This catches the case where the
|
|
|
|
* user has written "fc" on the RHS, probably intending a byte value
|
|
|
|
* rather than the fibre channel protocol.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (stnode_type_id(st_arg2) == STTYPE_FIELD) {
|
2012-06-03 09:26:15 +00:00
|
|
|
hfinfo = (header_field_info*)stnode_data(st_arg2);
|
2012-06-04 14:45:50 +00:00
|
|
|
if (hfinfo->type == FT_PROTOCOL) {
|
2015-01-18 10:22:19 +00:00
|
|
|
dfilter_fail(dfw, "Protocol (\"%s\") cannot appear on right-hand side of comparison.", hfinfo->abbrev);
|
2004-05-09 08:17:32 +00:00
|
|
|
THROW(TypeError);
|
2012-06-04 14:45:50 +00:00
|
|
|
}
|
2004-05-09 08:17:32 +00:00
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
switch (stnode_type_id(st_arg1)) {
|
|
|
|
case STTYPE_FIELD:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_FIELD(dfw, relation_string, can_func,
|
2003-08-27 15:23:11 +00:00
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
break;
|
|
|
|
case STTYPE_STRING:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_STRING(dfw, relation_string, can_func,
|
2003-08-27 15:23:11 +00:00
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
break;
|
|
|
|
case STTYPE_RANGE:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_RANGE(dfw, relation_string, can_func,
|
2003-08-27 15:23:11 +00:00
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
break;
|
2003-07-25 03:44:05 +00:00
|
|
|
case STTYPE_UNPARSED:
|
2016-09-19 01:48:50 +00:00
|
|
|
case STTYPE_CHARCONST:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_UNPARSED(dfw, relation_string, can_func,
|
2003-08-27 15:23:11 +00:00
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
2003-07-25 03:44:05 +00:00
|
|
|
break;
|
2006-05-02 14:26:17 +00:00
|
|
|
case STTYPE_FUNCTION:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation_LHS_FUNCTION(dfw, relation_string, can_func,
|
2006-05-02 14:26:17 +00:00
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2001-02-27 19:23:30 +00:00
|
|
|
|
|
|
|
case STTYPE_UNINITIALIZED:
|
|
|
|
case STTYPE_TEST:
|
|
|
|
case STTYPE_INTEGER:
|
|
|
|
case STTYPE_FVALUE:
|
2015-08-19 03:03:41 +00:00
|
|
|
case STTYPE_SET:
|
2011-04-27 04:24:44 +00:00
|
|
|
default:
|
2001-02-27 19:23:30 +00:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the semantics of any type of TEST */
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
check_test(dfwork_t *dfw, stnode_t *st_node, GPtrArray *deprecated)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2013-08-10 17:49:28 +00:00
|
|
|
test_op_t st_op, st_arg_op;
|
2001-02-01 20:21:25 +00:00
|
|
|
stnode_t *st_arg1, *st_arg2;
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
DebugLog((" 3 check_test(stnode_t *st_node = %p) [%u]\n", st_node, i));
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
sttype_test_get(st_node, &st_op, &st_arg1, &st_arg2);
|
|
|
|
|
|
|
|
switch (st_op) {
|
|
|
|
case TEST_OP_UNINITIALIZED:
|
|
|
|
g_assert_not_reached();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_EXISTS:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_exists(dfw, st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_NOT:
|
2015-01-18 10:22:19 +00:00
|
|
|
semcheck(dfw, st_arg1, deprecated);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_AND:
|
|
|
|
case TEST_OP_OR:
|
2013-08-10 17:49:28 +00:00
|
|
|
if (stnode_type_id(st_arg1) == STTYPE_TEST) {
|
|
|
|
sttype_test_get(st_arg1, &st_arg_op, NULL, NULL);
|
|
|
|
if (st_arg_op == TEST_OP_AND || st_arg_op == TEST_OP_OR) {
|
|
|
|
if (st_op != st_arg_op && !st_arg1->inside_brackets)
|
|
|
|
g_ptr_array_add(deprecated, g_strdup("suggest parentheses around '&&' within '||'"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (stnode_type_id(st_arg2) == STTYPE_TEST) {
|
|
|
|
sttype_test_get(st_arg2, &st_arg_op, NULL, NULL);
|
|
|
|
if (st_arg_op == TEST_OP_AND || st_arg_op == TEST_OP_OR) {
|
|
|
|
if (st_op != st_arg_op && !st_arg2->inside_brackets)
|
|
|
|
g_ptr_array_add(deprecated, g_strdup("suggest parentheses around '&&' within '||'"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
semcheck(dfw, st_arg1, deprecated);
|
|
|
|
semcheck(dfw, st_arg2, deprecated);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_EQ:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, "==", FALSE, ftype_can_eq, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_NE:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, "!=", FALSE, ftype_can_ne, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_GT:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, ">", FALSE, ftype_can_gt, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_GE:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, ">=", FALSE, ftype_can_ge, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_LT:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, "<", FALSE, ftype_can_lt, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_LE:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, "<=", FALSE, ftype_can_le, st_node, st_arg1, st_arg2);
|
2003-08-27 15:23:11 +00:00
|
|
|
break;
|
2004-02-27 12:00:32 +00:00
|
|
|
case TEST_OP_BITWISE_AND:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, "&", FALSE, ftype_can_bitwise_and, st_node, st_arg1, st_arg2);
|
2004-02-27 12:00:32 +00:00
|
|
|
break;
|
2003-08-27 15:23:11 +00:00
|
|
|
case TEST_OP_CONTAINS:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_relation(dfw, "contains", TRUE, ftype_can_contains, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
2003-12-06 16:35:20 +00:00
|
|
|
case TEST_OP_MATCHES:
|
2015-08-19 03:03:41 +00:00
|
|
|
check_relation(dfw, "matches", TRUE, ftype_can_matches, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
|
|
|
case TEST_OP_IN:
|
|
|
|
/* Use the ftype_can_eq as the items in the set are evaluated using the
|
|
|
|
* semantics of equality. */
|
|
|
|
check_relation(dfw, "in", FALSE, ftype_can_eq, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2003-08-27 15:23:11 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2003-12-09 23:02:40 +00:00
|
|
|
DebugLog((" 3 check_test(stnode_t *st_node = %p) [%u] - End\n", st_node, i++));
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the entire syntax tree. */
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2015-01-18 10:22:19 +00:00
|
|
|
semcheck(dfwork_t *dfw, stnode_t *st_node, GPtrArray *deprecated)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
DebugLog((" 2 semcheck(stnode_t *st_node = %p) [%u]\n", st_node, i++));
|
2003-07-25 03:44:05 +00:00
|
|
|
/* The parser assures that the top-most syntax-tree
|
|
|
|
* node will be a TEST node, no matter what. So assert that. */
|
2001-02-01 20:21:25 +00:00
|
|
|
switch (stnode_type_id(st_node)) {
|
|
|
|
case STTYPE_TEST:
|
2015-01-18 10:22:19 +00:00
|
|
|
check_test(dfw, st_node, deprecated);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the syntax tree for semantic errors, and convert
|
|
|
|
* some of the nodes into the form they need to be in order to
|
|
|
|
* later generate the DFVM bytecode. */
|
2001-02-01 20:21:25 +00:00
|
|
|
gboolean
|
2013-08-10 17:49:28 +00:00
|
|
|
dfw_semcheck(dfwork_t *dfw, GPtrArray *deprecated)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2007-04-17 15:13:17 +00:00
|
|
|
volatile gboolean ok_filter = TRUE;
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
2009-12-18 01:15:08 +00:00
|
|
|
|
2003-12-09 23:02:40 +00:00
|
|
|
DebugLog(("1 dfw_semcheck(dfwork_t *dfw = %p) [%u]\n", dfw, i));
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Instead of having to check for errors at every stage of
|
|
|
|
* the semantic-checking, the semantic-checking code will
|
|
|
|
* throw an exception if a problem is found. */
|
2001-02-01 20:21:25 +00:00
|
|
|
TRY {
|
2015-01-18 10:22:19 +00:00
|
|
|
semcheck(dfw, dfw->st_root, deprecated);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
CATCH(TypeError) {
|
2007-04-17 15:13:17 +00:00
|
|
|
ok_filter = FALSE;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
ENDTRY;
|
|
|
|
|
2007-04-17 15:13:17 +00:00
|
|
|
DebugLog(("1 dfw_semcheck(dfwork_t *dfw = %p) [%u] - Returns %d\n",
|
|
|
|
dfw, i++,ok_filter));
|
|
|
|
return ok_filter;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2015-02-13 19:02:43 +00:00
|
|
|
|
|
|
|
/*
|
2019-07-26 18:43:17 +00:00
|
|
|
* Editor modelines - https://www.wireshark.org/tools/modelines.html
|
2015-02-13 19:02:43 +00:00
|
|
|
*
|
|
|
|
* 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:
|
|
|
|
*/
|