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"
|
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
#define WS_LOG_DOMAIN LOG_DOMAIN_DFILTER
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
#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
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
#include <wsutil/ws_assert.h>
|
2021-09-26 15:28:39 +00:00
|
|
|
#include <wsutil/wslog.h>
|
2021-06-18 18:21:42 +00:00
|
|
|
|
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
|
|
|
|
2003-12-09 23:02:40 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2021-09-27 22:22:59 +00:00
|
|
|
semcheck(dfwork_t *dfw, stnode_t *st_node);
|
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
|
|
|
|
2021-10-05 11:13:15 +00:00
|
|
|
static void
|
|
|
|
check_function(dfwork_t *dfw, stnode_t *st_node);
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
static fvalue_t *
|
|
|
|
mk_fvalue_from_val_string(dfwork_t *dfw, header_field_info *hfinfo, const char *s);
|
|
|
|
|
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:
|
Add FT_STRINGZTRUNC.
FT_STRINGZPAD is for null-*padded* strings, where the field is in an
area of specified length, and, if the string is shorter than that
length, all bytes past the end of the string are NULs.
FT_STRINGZTRUNC is for null-*truncated* strings, where the field is in
an area of specified length and, if the string is shorter than that
length, there's a null character (which might be more than one byte, for
UCS-2, UTF-16, or UTF-32), and anything after that is not guaranteed to
have any particular value.
Use IS_FT_STRING() in some places rather than enumerating all the string
types, so that those places get automatically changed if the set of
string types changes.
2020-09-12 21:16:12 +00:00
|
|
|
case FT_STRINGZTRUNC:
|
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:
|
Add FT_STRINGZTRUNC.
FT_STRINGZPAD is for null-*padded* strings, where the field is in an
area of specified length, and, if the string is shorter than that
length, all bytes past the end of the string are NULs.
FT_STRINGZTRUNC is for null-*truncated* strings, where the field is in
an area of specified length and, if the string is shorter than that
length, there's a null character (which might be more than one byte, for
UCS-2, UTF-16, or UTF-32), and anything after that is not guaranteed to
have any particular value.
Use IS_FT_STRING() in some places rather than enumerating all the string
types, so that those places get automatically changed if the set of
string types changes.
2020-09-12 21:16:12 +00:00
|
|
|
case FT_STRINGZTRUNC:
|
2001-02-01 20:21:25 +00:00
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
case FT_NUM_TYPES:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
/* Gets an fvalue from a string, and sets the error message on failure. */
|
2021-10-06 17:51:02 +00:00
|
|
|
WS_RETNONNULL
|
2015-01-18 10:22:19 +00:00
|
|
|
static fvalue_t*
|
2021-10-06 17:51:02 +00:00
|
|
|
dfilter_fvalue_from_unparsed(dfwork_t *dfw, ftenum_t ftype, stnode_t *st,
|
|
|
|
gboolean allow_partial_value, header_field_info *hfinfo_value_string)
|
2015-01-18 10:22:19 +00:00
|
|
|
{
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue_t *fv;
|
|
|
|
const char *s = stnode_data(st);
|
|
|
|
|
|
|
|
/* Don't set the error message if it's already set. */
|
|
|
|
fv = fvalue_from_unparsed(ftype, s, allow_partial_value,
|
|
|
|
dfw->error_message == NULL ? &dfw->error_message : NULL);
|
|
|
|
if (fv == NULL && hfinfo_value_string) {
|
|
|
|
/* check value_string */
|
|
|
|
fv = mk_fvalue_from_val_string(dfw, hfinfo_value_string, s);
|
|
|
|
/*
|
|
|
|
* Ignore previous errors if this can be mapped
|
|
|
|
* to an item from value_string.
|
|
|
|
*/
|
|
|
|
if (fv && dfw->error_message) {
|
|
|
|
g_free(dfw->error_message);
|
|
|
|
dfw->error_message = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fv == NULL)
|
|
|
|
THROW(TypeError);
|
|
|
|
return fv;
|
2015-01-18 10:22:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Gets an fvalue from a string, and sets the error message on failure. */
|
2021-10-06 17:51:02 +00:00
|
|
|
WS_RETNONNULL
|
2015-01-18 10:22:19 +00:00
|
|
|
static fvalue_t*
|
2021-10-06 17:51:02 +00:00
|
|
|
dfilter_fvalue_from_string(dfwork_t *dfw, ftenum_t ftype, stnode_t *st,
|
|
|
|
header_field_info *hfinfo_value_string)
|
2015-01-18 10:22:19 +00:00
|
|
|
{
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue_t *fv;
|
|
|
|
const char *s = stnode_data(st);
|
|
|
|
|
|
|
|
fv = fvalue_from_string(ftype, s,
|
2015-01-18 10:22:19 +00:00
|
|
|
dfw->error_message == NULL ? &dfw->error_message : NULL);
|
2021-10-06 17:51:02 +00:00
|
|
|
if (fv == NULL && hfinfo_value_string) {
|
|
|
|
fv = mk_fvalue_from_val_string(dfw, hfinfo_value_string, s);
|
|
|
|
/*
|
|
|
|
* Ignore previous errors if this can be mapped
|
|
|
|
* to an item from value_string.
|
|
|
|
*/
|
|
|
|
if (fv && dfw->error_message) {
|
|
|
|
g_free(dfw->error_message);
|
|
|
|
dfw->error_message = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fv == NULL)
|
|
|
|
THROW(TypeError);
|
|
|
|
return fv;
|
2015-01-18 10:22:19 +00:00
|
|
|
}
|
|
|
|
|
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*
|
2021-10-06 17:51:02 +00:00
|
|
|
mk_fvalue_from_val_string(dfwork_t *dfw, header_field_info *hfinfo, const 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:
|
Add FT_STRINGZTRUNC.
FT_STRINGZPAD is for null-*padded* strings, where the field is in an
area of specified length, and, if the string is shorter than that
length, all bytes past the end of the string are NULs.
FT_STRINGZTRUNC is for null-*truncated* strings, where the field is in
an area of specified length and, if the string is shorter than that
length, there's a null character (which might be more than one byte, for
UCS-2, UTF-16, or UTF-32), and anything after that is not guaranteed to
have any particular value.
Use IS_FT_STRING() in some places rather than enumerating all the string
types, so that those places get automatically changed if the set of
string types changes.
2020-09-12 21:16:12 +00:00
|
|
|
case FT_STRINGZTRUNC:
|
2011-05-08 10:23:53 +00:00
|
|
|
case FT_EUI64:
|
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:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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:
|
Add FT_STRINGZTRUNC.
FT_STRINGZPAD is for null-*padded* strings, where the field is in an
area of specified length, and, if the string is shorter than that
length, all bytes past the end of the string are NULs.
FT_STRINGZTRUNC is for null-*truncated* strings, where the field is in
an area of specified length and, if the string is shorter than that
length, there's a null character (which might be more than one byte, for
UCS-2, UTF-16, or UTF-32), and anything after that is not guaranteed to
have any particular value.
Use IS_FT_STRING() in some places rather than enumerating all the string
types, so that those places get automatically changed if the set of
string types changes.
2020-09-12 21:16:12 +00:00
|
|
|
case FT_STRINGZTRUNC:
|
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:
|
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:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2021-03-21 10:06:17 +00:00
|
|
|
/* Gets a GRegex from a string, and sets the error message on failure. */
|
2021-10-06 17:51:02 +00:00
|
|
|
WS_RETNONNULL
|
2021-03-21 10:06:17 +00:00
|
|
|
static GRegex*
|
2021-10-06 17:51:02 +00:00
|
|
|
dfilter_g_regex_from_string(dfwork_t *dfw, stnode_t *st)
|
2021-03-21 10:06:17 +00:00
|
|
|
{
|
|
|
|
GError *regex_error = NULL;
|
|
|
|
GRegexCompileFlags cflags = (GRegexCompileFlags)(G_REGEX_CASELESS | G_REGEX_OPTIMIZE);
|
|
|
|
GRegex *pcre;
|
2021-10-06 17:51:02 +00:00
|
|
|
const char *s = stnode_data(st);
|
2021-03-21 10:06:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* As FT_BYTES and FT_PROTOCOL contain arbitrary binary data
|
|
|
|
* and FT_STRING is not guaranteed to contain valid UTF-8,
|
|
|
|
* we have to disable support for UTF-8 patterns and treat
|
|
|
|
* every pattern and subject as raw bytes.
|
|
|
|
*
|
|
|
|
* Should support for UTF-8 patterns be necessary, then we
|
|
|
|
* should compile a pattern without G_REGEX_RAW. Additionally,
|
|
|
|
* we MUST use g_utf8_validate() before calling g_regex_match_full()
|
|
|
|
* or risk crashes.
|
|
|
|
*/
|
|
|
|
cflags = (GRegexCompileFlags)(cflags | G_REGEX_RAW);
|
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("Compile regex pattern: %s", s);
|
2021-05-30 02:38:12 +00:00
|
|
|
|
2021-03-21 10:06:17 +00:00
|
|
|
pcre = g_regex_new(
|
|
|
|
s, /* pattern */
|
|
|
|
cflags, /* Compile options */
|
|
|
|
(GRegexMatchFlags)0, /* Match options */
|
|
|
|
®ex_error /* Compile / study errors */
|
|
|
|
);
|
|
|
|
|
|
|
|
if (regex_error) {
|
|
|
|
if (dfw->error_message == NULL)
|
|
|
|
dfw->error_message = g_strdup(regex_error->message);
|
|
|
|
g_error_free(regex_error);
|
|
|
|
if (pcre) {
|
|
|
|
g_regex_unref(pcre);
|
|
|
|
}
|
2021-10-06 17:51:02 +00:00
|
|
|
THROW(TypeError);
|
2021-03-21 10:06:17 +00:00
|
|
|
}
|
|
|
|
return pcre;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2021-09-26 15:28:39 +00:00
|
|
|
#ifndef WS_DISABLE_DEBUG
|
2004-02-11 21:20:52 +00:00
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("4 check_exists() [%u]", i++);
|
2021-09-30 19:09:17 +00:00
|
|
|
log_stnode(st_arg1);
|
2021-09-26 15:28:39 +00:00
|
|
|
|
2004-02-11 21:20:52 +00:00
|
|
|
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:
|
2021-03-21 10:06:17 +00:00
|
|
|
case STTYPE_PCRE:
|
2004-02-11 21:20:52 +00:00
|
|
|
case STTYPE_NUM_TYPES:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2004-02-11 21:20:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
|
|
|
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:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2004-06-03 07:33:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
{
|
2021-10-05 11:13:15 +00:00
|
|
|
stnode_t *entity1;
|
|
|
|
header_field_info *hfinfo1;
|
|
|
|
ftenum_t ftype1;
|
2004-06-03 07:33:46 +00:00
|
|
|
struct check_drange_sanity_args args;
|
2021-10-05 11:13:15 +00:00
|
|
|
char *s;
|
|
|
|
|
|
|
|
entity1 = sttype_range_entity(st);
|
|
|
|
if (entity1 && stnode_type_id(entity1) == STTYPE_FIELD) {
|
|
|
|
hfinfo1 = (header_field_info *)stnode_data(entity1);
|
|
|
|
ftype1 = hfinfo1->type;
|
|
|
|
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
|
|
|
dfilter_fail(dfw, "\"%s\" is a %s and cannot be sliced into a sequence of bytes.",
|
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
} 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)) {
|
|
|
|
dfilter_fail(dfw, "Return value of function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
|
|
|
funcdef->name, ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
check_function(dfw, entity1);
|
|
|
|
} else if (entity1 && stnode_type_id(entity1) == STTYPE_RANGE) {
|
|
|
|
/* Should this be rejected instead? */
|
|
|
|
check_drange_sanity(dfw, entity1);
|
|
|
|
} else if (entity1) {
|
|
|
|
s = stnode_tostr(entity1);
|
|
|
|
dfilter_fail(dfw, "Range is not supported for entity %s of type %s",
|
|
|
|
s, stnode_type_name(entity1));
|
|
|
|
g_free(s);
|
|
|
|
THROW(TypeError);
|
|
|
|
} else {
|
|
|
|
dfilter_fail(dfw, "Range is not supported, details: " G_STRLOC " entity: NULL");
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2004-06-03 07:33:46 +00:00
|
|
|
|
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;
|
|
|
|
|
2021-09-26 21:22:50 +00:00
|
|
|
new_st = stnode_new(STTYPE_RANGE, NULL, arg->token_value);
|
2013-07-28 08:41:26 +00:00
|
|
|
|
|
|
|
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. */
|
2021-10-06 17:51:02 +00:00
|
|
|
WS_RETNONNULL
|
2016-09-19 01:48:50 +00:00
|
|
|
static fvalue_t *
|
2021-10-06 17:51:02 +00:00
|
|
|
dfilter_fvalue_from_charconst_string(dfwork_t *dfw, ftenum_t ftype, stnode_t *st, gboolean allow_partial_value)
|
2016-09-19 01:48:50 +00:00
|
|
|
{
|
|
|
|
fvalue_t *fvalue;
|
2021-10-06 17:51:02 +00:00
|
|
|
const char *s = stnode_data(st);
|
2016-09-19 01:48:50 +00:00
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = fvalue_from_unparsed(ftype, s, allow_partial_value,
|
|
|
|
dfw->error_message == NULL ? &dfw->error_message : NULL);
|
|
|
|
if (fvalue == NULL)
|
|
|
|
THROW(TypeError);
|
|
|
|
|
|
|
|
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);
|
|
|
|
fvalue = fvalue_from_unparsed(ftype, temp_string, allow_partial_value, NULL);
|
|
|
|
ws_assert(fvalue);
|
|
|
|
g_free(temp_string);
|
|
|
|
|
|
|
|
return fvalue;
|
2016-09-19 01:48:50 +00:00
|
|
|
}
|
|
|
|
|
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;
|
2021-03-21 10:06:17 +00:00
|
|
|
GRegex *pcre;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
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) {
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_FIELD(%s)", relation_string);
|
2015-08-19 03:03:41 +00:00
|
|
|
} else {
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("6 check_relation_LHS_FIELD(%s)", relation_string);
|
2015-08-19 03:03:41 +00:00
|
|
|
}
|
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) {
|
2003-12-09 23:02:40 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
2021-03-21 10:06:17 +00:00
|
|
|
/* Convert to a GRegex */
|
2021-10-06 17:51:02 +00:00
|
|
|
pcre = dfilter_g_regex_from_string(dfw, st_arg2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_PCRE, pcre);
|
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;
|
|
|
|
}
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
if (type2 == STTYPE_STRING) {
|
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype1, st_arg2, NULL);
|
|
|
|
}
|
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. */
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_charconst_string(dfw, ftype1, st_arg2, allow_partial_value);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2021-10-06 17:51:02 +00:00
|
|
|
else {
|
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype1, st_arg2, allow_partial_value, hfinfo1);
|
2021-03-21 10:06:17 +00:00
|
|
|
}
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
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) {
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2015-08-19 03:03:41 +00:00
|
|
|
}
|
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);
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(nodelist);
|
2018-04-14 16:07:22 +00:00
|
|
|
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 {
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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_,
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_t *st_node _U_,
|
2001-02-27 19:23:30 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
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;
|
|
|
|
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_STRING()");
|
2004-01-01 16:59:20 +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;
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype2, st_arg1, hfinfo2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg1, STTYPE_FVALUE, fvalue);
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
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);
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_BYTES, st_arg1, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg1, STTYPE_FVALUE, fvalue);
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
2021-10-06 17:51:02 +00:00
|
|
|
check_function(dfw, st_arg2);
|
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype2, st_arg1, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg1, STTYPE_FVALUE, fvalue);
|
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-27 19:23:30 +00:00
|
|
|
else {
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
}
|
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,
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_t *st_node _U_,
|
2003-07-25 03:44:05 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
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;
|
|
|
|
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_UNPARSED()");
|
2004-01-01 16:59:20 +00:00
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype2, st_arg1, allow_partial_value, hfinfo2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg1, STTYPE_FVALUE, fvalue);
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
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);
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_BYTES, st_arg1, allow_partial_value, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg1, STTYPE_FVALUE, fvalue);
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
2021-10-06 17:51:02 +00:00
|
|
|
check_function(dfw, st_arg2);
|
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype2, st_arg1, allow_partial_value, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg1, STTYPE_FVALUE, fvalue);
|
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);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
else {
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
2021-10-05 11:13:15 +00:00
|
|
|
header_field_info *hfinfo2;
|
|
|
|
ftenum_t ftype2;
|
2001-02-27 19:23:30 +00:00
|
|
|
fvalue_t *fvalue;
|
2021-03-21 10:06:17 +00:00
|
|
|
GRegex *pcre;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_RANGE(%s)", relation_string);
|
2004-01-01 16:59:20 +00:00
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
check_drange_sanity(dfw, st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2021-10-05 11:13:15 +00:00
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_RANGE(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 (!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) {
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_RANGE(type2 = STTYPE_STRING)");
|
2004-01-01 16:59:20 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
2021-03-21 10:06:17 +00:00
|
|
|
/* Convert to a GRegex * */
|
2021-10-06 17:51:02 +00:00
|
|
|
pcre = dfilter_g_regex_from_string(dfw, st_arg2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_PCRE, pcre);
|
2004-01-01 16:59:20 +00:00
|
|
|
} else {
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_BYTES, st_arg2, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2004-01-01 16:59:20 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED) {
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_RANGE(type2 = STTYPE_UNPARSED)");
|
2004-01-01 16:59:20 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
2021-03-21 10:06:17 +00:00
|
|
|
/* Convert to a GRegex */
|
2021-10-06 17:51:02 +00:00
|
|
|
pcre = dfilter_g_regex_from_string(dfw, st_arg2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_PCRE, pcre);
|
2021-03-21 10:06:17 +00:00
|
|
|
} else {
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_BYTES, st_arg2, allow_partial_value, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
|
|
|
}
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_CHARCONST) {
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_RANGE(type2 = STTYPE_CHARCONST)");
|
2016-09-19 01:48:50 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
2021-03-21 10:06:17 +00:00
|
|
|
/* Convert to a GRegex */
|
2021-10-06 17:51:02 +00:00
|
|
|
pcre = dfilter_g_regex_from_string(dfw, st_arg2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_PCRE, pcre);
|
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. */
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_charconst_string(dfw, FT_BYTES, st_arg2, allow_partial_value);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2016-09-19 01:48:50 +00:00
|
|
|
}
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_RANGE(type2 = STTYPE_RANGE)");
|
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 {
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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) {
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_STRING, st_node, TRUE, NULL);
|
2021-09-26 21:22:50 +00:00
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue, st_node->token_value);
|
2006-05-02 14:26:17 +00:00
|
|
|
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;
|
2021-03-21 10:06:17 +00:00
|
|
|
GRegex *pcre;
|
2021-03-21 09:15:00 +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
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("5 check_relation_LHS_FUNCTION(%s)", relation_string);
|
2006-05-02 14:26:17 +00:00
|
|
|
|
|
|
|
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) {
|
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
2021-03-21 10:06:17 +00:00
|
|
|
/* Convert to a GRegex */
|
2021-10-06 17:51:02 +00:00
|
|
|
pcre = dfilter_g_regex_from_string(dfw, st_arg2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_PCRE, pcre);
|
2006-05-02 14:26:17 +00:00
|
|
|
} else {
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype1, st_arg2, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
}
|
2016-09-19 01:48:50 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED || type2 == STTYPE_CHARCONST) {
|
2006-05-02 14:26:17 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
2021-03-21 10:06:17 +00:00
|
|
|
/* Convert to a GRegex */
|
2021-10-06 17:51:02 +00:00
|
|
|
pcre = dfilter_g_regex_from_string(dfw, st_arg2);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_PCRE, pcre);
|
2006-05-02 14:26:17 +00:00
|
|
|
} else {
|
2021-10-06 17:51:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype1, st_arg2, allow_partial_value, NULL);
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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 {
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2021-09-26 15:28:39 +00:00
|
|
|
#ifndef WS_DISABLE_DEBUG
|
2003-12-09 23:02:40 +00:00
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
2021-09-17 00:15:54 +00:00
|
|
|
header_field_info *hfinfo;
|
|
|
|
char *s;
|
2003-12-09 23:02:40 +00:00
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("4 check_relation(\"%s\") [%u]", relation_string, i++);
|
2021-09-30 19:09:17 +00:00
|
|
|
log_stnode(st_arg1);
|
|
|
|
log_stnode(st_arg2);
|
2004-05-09 08:17:32 +00:00
|
|
|
|
|
|
|
/* Protocol can only be on LHS (for "contains" or "matches" operators).
|
2021-09-19 15:23:26 +00:00
|
|
|
* Check to see if protocol is on RHS, and re-interpret it as UNPARSED
|
|
|
|
* instead. The subsequent functions will parse it according to the
|
|
|
|
* existing rules for unparsed unquoted strings.
|
|
|
|
*
|
2021-09-17 00:15:54 +00:00
|
|
|
* This catches the case where the user has written "fc" on the RHS,
|
|
|
|
* probably intending a byte value rather than the fibre channel
|
2021-09-19 15:23:26 +00:00
|
|
|
* protocol, or similar for a number of other possibilities
|
|
|
|
* ("dc", "ff", "fefd"), and also catches the case where the user
|
|
|
|
* has written a generic string on the RHS for a "contains" or
|
|
|
|
* "matches" relation. (XXX: There's still a bit of a confusing mess;
|
|
|
|
* byte arrays take precedent over generic strings when unquoted, so
|
|
|
|
* "field contains data" matches "\x64 \x61 \x74 \x61" but
|
|
|
|
* "field contains dc" matches "\xdc" and not "\x64 \x43", but that's
|
|
|
|
* an underlying issue.)
|
2021-09-17 00:15:54 +00:00
|
|
|
*
|
|
|
|
* XXX: Is there a better way to do this in the lex scanner or grammar
|
2021-09-19 15:23:26 +00:00
|
|
|
* parser step instead? Should the determination of whether something
|
|
|
|
* is a field occur later than it does currently? This is kind of a
|
|
|
|
* hack.
|
2004-05-09 08:17:32 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
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) {
|
2021-09-17 00:15:54 +00:00
|
|
|
/* Discard const qualifier from hfinfo->abbrev
|
|
|
|
* for sttnode_new, even though it duplicates the
|
|
|
|
* string.
|
|
|
|
*/
|
|
|
|
s = (char *)hfinfo->abbrev;
|
2021-09-19 15:23:26 +00:00
|
|
|
/* Send it through as unparsed and all the other
|
2021-09-17 00:15:54 +00:00
|
|
|
* functions will take care of it as if it didn't
|
|
|
|
* match a protocol string.
|
|
|
|
*/
|
2021-10-06 09:21:37 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_UNPARSED, s);
|
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:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
2021-09-27 22:22:59 +00:00
|
|
|
check_test(dfwork_t *dfw, stnode_t *st_node)
|
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;
|
2021-09-26 15:28:39 +00:00
|
|
|
#ifndef WS_DISABLE_DEBUG
|
2003-12-09 23:02:40 +00:00
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("3 check_test(stnode_t *st_node = %p) [%u]\n", st_node, i++);
|
2021-09-30 19:09:17 +00:00
|
|
|
log_stnode(st_node);
|
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:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
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:
|
2021-09-27 22:22:59 +00:00
|
|
|
semcheck(dfw, st_arg1);
|
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) {
|
2021-09-27 00:54:41 +00:00
|
|
|
if (st_op != st_arg_op && !stnode_inside_parens(st_arg1))
|
2021-09-27 22:22:59 +00:00
|
|
|
g_ptr_array_add(dfw->deprecated, g_strdup("suggest parentheses around '&&' within '||'"));
|
2013-08-10 17:49:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
2021-09-27 00:54:41 +00:00
|
|
|
if (st_op != st_arg_op && !stnode_inside_parens(st_arg2))
|
2021-09-27 22:22:59 +00:00
|
|
|
g_ptr_array_add(dfw->deprecated, g_strdup("suggest parentheses around '&&' within '||'"));
|
2013-08-10 17:49:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-27 22:22:59 +00:00
|
|
|
semcheck(dfw, st_arg1);
|
|
|
|
semcheck(dfw, st_arg2);
|
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:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
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
|
2021-09-27 22:22:59 +00:00
|
|
|
semcheck(dfwork_t *dfw, stnode_t *st_node)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2021-09-26 15:28:39 +00:00
|
|
|
#ifndef WS_DISABLE_DEBUG
|
2003-12-09 23:02:40 +00:00
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("2 semcheck(stnode_t *st_node = %p) [%u]", 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:
|
2021-09-27 22:22:59 +00:00
|
|
|
check_test(dfw, st_node);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
default:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
2021-09-27 22:22:59 +00:00
|
|
|
dfw_semcheck(dfwork_t *dfw)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2007-04-17 15:13:17 +00:00
|
|
|
volatile gboolean ok_filter = TRUE;
|
2021-09-26 15:28:39 +00:00
|
|
|
#ifndef WS_DISABLE_DEBUG
|
2003-12-09 23:02:40 +00:00
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
2009-12-18 01:15:08 +00:00
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("1 dfw_semcheck(dfwork_t *dfw = %p) [%u]", 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 {
|
2021-09-27 22:22:59 +00:00
|
|
|
semcheck(dfw, dfw->st_root);
|
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;
|
|
|
|
|
2021-09-26 15:28:39 +00:00
|
|
|
ws_debug("1 dfw_semcheck(dfwork_t *dfw = %p) [%u] - Returns %d",
|
|
|
|
dfw, i++, ok_filter);
|
2007-04-17 15:13:17 +00:00
|
|
|
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:
|
|
|
|
*/
|