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"
|
2022-04-09 22:03:40 +00:00
|
|
|
#include "sttype-pointer.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
|
|
|
|
2021-11-11 00:54:00 +00:00
|
|
|
#include <ftypes/ftypes.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
|
|
|
|
2022-04-07 12:57:39 +00:00
|
|
|
#define FAIL(dfw, node, ...) \
|
2022-02-27 09:56:41 +00:00
|
|
|
do { \
|
|
|
|
ws_noisy("Semantic check failed here."); \
|
2022-04-12 15:13:08 +00:00
|
|
|
dfilter_fail_throw(dfw, stnode_location(node), __VA_ARGS__); \
|
2022-02-27 09:56:41 +00:00
|
|
|
} while (0)
|
2021-11-08 12:20: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
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2022-04-01 12:32:16 +00:00
|
|
|
static gboolean
|
|
|
|
node_is_constant(stnode_t *node)
|
|
|
|
{
|
|
|
|
switch (stnode_type_id(node)) {
|
|
|
|
case STTYPE_CHARCONST:
|
|
|
|
case STTYPE_STRING:
|
|
|
|
case STTYPE_LITERAL:
|
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2015-01-18 10:22:19 +00:00
|
|
|
/* Gets an fvalue from a string, and sets the error message on failure. */
|
2022-03-25 17:46:16 +00:00
|
|
|
WS_RETNONNULL
|
2022-04-12 15:13:08 +00:00
|
|
|
fvalue_t*
|
2022-03-25 17:46:16 +00:00
|
|
|
dfilter_fvalue_from_literal(dfwork_t *dfw, ftenum_t ftype, stnode_t *st,
|
2021-10-06 17:51:02 +00:00
|
|
|
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. */
|
2022-02-23 00:47:00 +00:00
|
|
|
fv = fvalue_from_literal(ftype, s, allow_partial_value,
|
2021-10-06 17:51:02 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2022-04-07 12:57:39 +00:00
|
|
|
if (fv == NULL) {
|
|
|
|
dfw_set_error_location(dfw, stnode_location(st));
|
2021-10-06 17:51:02 +00:00
|
|
|
THROW(TypeError);
|
2022-04-07 12:57:39 +00:00
|
|
|
}
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
return fv;
|
2015-01-18 10:22:19 +00:00
|
|
|
}
|
|
|
|
|
2022-04-12 15:13:08 +00:00
|
|
|
fvalue_t *
|
2022-04-06 20:59: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)
|
|
|
|
{
|
|
|
|
fvalue_t *fv;
|
|
|
|
const char *s = stnode_data(st);
|
|
|
|
|
|
|
|
/* Don't set the error message if it's already set. */
|
|
|
|
fv = fvalue_from_literal(ftype, s, allow_partial_value,
|
|
|
|
dfw->error_message == NULL ? &dfw->error_message : NULL);
|
|
|
|
|
|
|
|
if (fv != NULL) {
|
|
|
|
/* converted to fvalue successfully. */
|
|
|
|
return fv;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hfinfo_value_string) {
|
|
|
|
/* check value_string */
|
|
|
|
fv = mk_fvalue_from_val_string(dfw, hfinfo_value_string, s);
|
|
|
|
|
|
|
|
if (fv != NULL) {
|
|
|
|
/*
|
|
|
|
* Ignore previous errors if this can be mapped
|
|
|
|
* to an item from value_string.
|
|
|
|
*/
|
|
|
|
g_free(dfw->error_message);
|
|
|
|
dfw->error_message = NULL;
|
|
|
|
return fv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
header_field_info *hfinfo = dfilter_resolve_unparsed(dfw, s);
|
|
|
|
|
|
|
|
if (hfinfo == NULL) {
|
|
|
|
/* This node is neither a valid fvalue nor a valid field. */
|
|
|
|
/* The parse failed. Error message is already set. */
|
2022-04-07 12:57:39 +00:00
|
|
|
dfw_set_error_location(dfw, stnode_location(st));
|
2022-04-06 20:59:02 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Successfully resolved to a field. */
|
|
|
|
|
|
|
|
/* Free the error message for the failed fvalue_from_literal() attempt. */
|
|
|
|
g_free(dfw->error_message);
|
|
|
|
dfw->error_message = NULL;
|
|
|
|
|
|
|
|
stnode_replace(st, STTYPE_FIELD, hfinfo);
|
|
|
|
/* Return NULL to signal we have a field. */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
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
|
2022-04-12 15:13:08 +00:00
|
|
|
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;
|
2022-06-18 09:43:24 +00:00
|
|
|
const GString *gs = stnode_string(st);
|
2021-10-06 17:51:02 +00:00
|
|
|
|
2022-06-18 09:43:24 +00:00
|
|
|
fv = fvalue_from_string(ftype, gs->str, gs->len,
|
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) {
|
2022-06-18 09:43:24 +00:00
|
|
|
fv = mk_fvalue_from_val_string(dfw, hfinfo_value_string, gs->str);
|
2021-10-06 17:51:02 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
}
|
2022-04-07 12:57:39 +00:00
|
|
|
if (fv == NULL) {
|
|
|
|
dfw_set_error_location(dfw, stnode_location(st));
|
2021-10-06 17:51:02 +00:00
|
|
|
THROW(TypeError);
|
2022-04-07 12:57:39 +00:00
|
|
|
}
|
|
|
|
|
2021-10-06 17:51:02 +00:00
|
|
|
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;
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, NULL, "\"%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) {
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, NULL, "%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) {
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, NULL, "\"%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++;
|
|
|
|
}
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, NULL, "\"%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.
|
|
|
|
* -><-
|
|
|
|
*/
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, NULL, "\"%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
|
|
|
}
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, NULL, "\"%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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_arg1);
|
|
|
|
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, st_arg1);
|
2022-02-20 00:14:24 +00:00
|
|
|
|
2004-02-11 21:20:52 +00:00
|
|
|
switch (stnode_type_id(st_arg1)) {
|
|
|
|
case STTYPE_FIELD:
|
2022-04-04 10:33:38 +00:00
|
|
|
case STTYPE_ARITHMETIC:
|
2022-04-09 22:03:40 +00:00
|
|
|
case STTYPE_LAYER:
|
2004-02-11 21:20:52 +00:00
|
|
|
/* This is OK */
|
|
|
|
break;
|
2022-03-27 14:26:46 +00:00
|
|
|
case STTYPE_REFERENCE:
|
2004-02-11 21:20:52 +00:00
|
|
|
case STTYPE_STRING:
|
2022-02-23 00:47:00 +00:00
|
|
|
case STTYPE_LITERAL:
|
2021-11-27 17:31:16 +00:00
|
|
|
case STTYPE_CHARCONST:
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "%s is neither a field nor a protocol name.",
|
2021-11-08 12:20:40 +00:00
|
|
|
stnode_todisplay(st_arg1));
|
2004-02-11 21:20:52 +00:00
|
|
|
break;
|
|
|
|
|
2022-04-11 19:06:49 +00:00
|
|
|
case STTYPE_SLICE:
|
2004-02-11 21:20:52 +00:00
|
|
|
/*
|
|
|
|
* 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"?
|
|
|
|
*/
|
2022-04-11 19:06:49 +00:00
|
|
|
FAIL(dfw, st_arg1, "You cannot test whether a slice is present.");
|
2004-02-11 21:20:52 +00:00
|
|
|
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. */
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "You cannot test whether a function is present.");
|
2006-05-02 14:26:17 +00:00
|
|
|
break;
|
|
|
|
|
2022-04-04 15:52:11 +00:00
|
|
|
case STTYPE_SET:
|
|
|
|
case STTYPE_UNPARSED:
|
|
|
|
case STTYPE_UNINITIALIZED:
|
|
|
|
case STTYPE_NUM_TYPES:
|
|
|
|
case STTYPE_TEST:
|
|
|
|
case STTYPE_FVALUE:
|
|
|
|
case STTYPE_PCRE:
|
2022-04-07 23:12:56 +00:00
|
|
|
case STTYPE_RANGE_NODE:
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2004-02-11 21:20:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
static void
|
|
|
|
check_exists_layer(dfwork_t *dfw, stnode_t *st_arg1)
|
|
|
|
{
|
|
|
|
stnode_t *entity;
|
|
|
|
|
|
|
|
entity = sttype_range_entity(st_arg1);
|
|
|
|
dfw_resolve_unparsed(dfw, entity);
|
|
|
|
check_exists(dfw, entity);
|
|
|
|
/* Nothing to do here? */
|
|
|
|
}
|
|
|
|
|
2004-06-03 07:33:46 +00:00
|
|
|
static void
|
2022-04-11 19:06:49 +00:00
|
|
|
check_slice_sanity(dfwork_t *dfw, stnode_t *st, ftenum_t lhs_ftype)
|
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;
|
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st);
|
|
|
|
|
2021-10-05 11:13:15 +00:00
|
|
|
entity1 = sttype_range_entity(st);
|
2021-11-08 01:05:53 +00:00
|
|
|
ws_assert(entity1);
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, entity1);
|
2021-11-08 01:05:53 +00:00
|
|
|
|
|
|
|
if (stnode_type_id(entity1) == STTYPE_FIELD) {
|
|
|
|
hfinfo1 = stnode_data(entity1);
|
2021-10-05 11:13:15 +00:00
|
|
|
ftype1 = hfinfo1->type;
|
|
|
|
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, entity1, "\"%s\" is a %s and cannot be sliced into a sequence of bytes.",
|
2021-10-05 11:13:15 +00:00
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1));
|
|
|
|
}
|
2021-11-08 01:05:53 +00:00
|
|
|
} else if (stnode_type_id(entity1) == STTYPE_FUNCTION) {
|
2022-04-16 01:42:20 +00:00
|
|
|
ftype1 = check_function(dfw, entity1, lhs_ftype);
|
2021-10-05 11:13:15 +00:00
|
|
|
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, entity1, "Return value of function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(entity1), ftype_pretty_name(ftype1));
|
2021-10-05 11:13:15 +00:00
|
|
|
}
|
2022-04-11 19:06:49 +00:00
|
|
|
} else if (stnode_type_id(entity1) == STTYPE_SLICE) {
|
2021-10-05 11:13:15 +00:00
|
|
|
/* Should this be rejected instead? */
|
2022-04-11 19:06:49 +00:00
|
|
|
check_slice_sanity(dfw, entity1, lhs_ftype);
|
2021-11-08 01:05:53 +00:00
|
|
|
} else {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, entity1, "Range is not supported for entity %s",
|
2022-02-20 00:14:24 +00:00
|
|
|
stnode_todisplay(entity1));
|
2021-10-05 11:13:15 +00:00
|
|
|
}
|
2004-06-03 07:33:46 +00:00
|
|
|
}
|
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
static ftenum_t
|
|
|
|
check_layer_sanity(dfwork_t *dfw, stnode_t *st)
|
|
|
|
{
|
|
|
|
stnode_t *entity1;
|
|
|
|
sttype_id_t e_type;
|
|
|
|
|
|
|
|
LOG_NODE(st);
|
|
|
|
|
|
|
|
entity1 = sttype_range_entity(st);
|
|
|
|
ws_assert(entity1);
|
|
|
|
dfw_resolve_unparsed(dfw, entity1);
|
|
|
|
e_type = stnode_type_id(entity1);
|
|
|
|
|
|
|
|
if (e_type == STTYPE_FIELD) {
|
|
|
|
return sttype_pointer_ftenum(entity1);
|
|
|
|
}
|
|
|
|
else if (e_type == STTYPE_REFERENCE) {
|
|
|
|
/* TODO: Implement layers with references. */
|
|
|
|
FAIL(dfw, entity1, "The # operator is not valid with a reference");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
FAIL(dfw, entity1, "%s is not a valid field value", stnode_todisplay(entity1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define IS_FIELD_ENTITY(ft) \
|
|
|
|
((ft) == STTYPE_FIELD || \
|
|
|
|
(ft) == STTYPE_REFERENCE || \
|
|
|
|
(ft) == STTYPE_LAYER)
|
|
|
|
|
|
|
|
static ftenum_t
|
|
|
|
field_ftenum(stnode_t *st)
|
|
|
|
{
|
|
|
|
sttype_id_t e_type;
|
|
|
|
|
|
|
|
e_type = stnode_type_id(st);
|
|
|
|
if (e_type == STTYPE_FIELD || e_type == STTYPE_REFERENCE)
|
|
|
|
return sttype_pointer_ftenum(st);
|
|
|
|
else if (e_type == STTYPE_LAYER) {
|
|
|
|
return sttype_pointer_ftenum(sttype_range_entity(st));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ws_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-09 00:34:31 +00:00
|
|
|
static void
|
2013-07-28 08:41:26 +00:00
|
|
|
convert_to_bytes(stnode_t *arg)
|
|
|
|
{
|
2021-10-09 00:34:31 +00:00
|
|
|
stnode_t *entity1;
|
2013-07-28 08:41:26 +00:00
|
|
|
drange_node *rn;
|
|
|
|
|
2021-10-09 00:34:31 +00:00
|
|
|
entity1 = stnode_dup(arg);
|
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);
|
|
|
|
|
2022-04-11 19:06:49 +00:00
|
|
|
stnode_replace(arg, STTYPE_SLICE, NULL);
|
2021-10-09 00:34:31 +00:00
|
|
|
sttype_range_set1(arg, entity1, rn);
|
2013-07-28 08:41:26 +00:00
|
|
|
}
|
|
|
|
|
2022-04-16 01:42:20 +00:00
|
|
|
ftenum_t
|
|
|
|
check_function(dfwork_t *dfw, stnode_t *st_node, ftenum_t lhs_ftype)
|
2009-05-31 19:46:31 +00:00
|
|
|
{
|
|
|
|
df_func_def_t *funcdef;
|
|
|
|
GSList *params;
|
2009-12-18 01:15:08 +00:00
|
|
|
guint nparams;
|
2009-05-31 19:46:31 +00:00
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
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) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_node, "Function %s needs at least %u arguments.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, funcdef->min_nargs);
|
2022-04-12 15:13:08 +00:00
|
|
|
} else if (funcdef->max_nargs > 0 && nparams > funcdef->max_nargs) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_node, "Function %s can only accept %u arguments.",
|
2009-05-31 19:46:31 +00:00
|
|
|
funcdef->name, funcdef->max_nargs);
|
|
|
|
}
|
|
|
|
|
2022-04-16 01:42:20 +00:00
|
|
|
return funcdef->semcheck_param_function(dfw, funcdef->name, lhs_ftype, params,
|
2022-04-12 15:13:08 +00:00
|
|
|
stnode_location(st_node));
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
|
|
|
|
2021-11-23 16:02:35 +00:00
|
|
|
WS_RETNONNULL
|
2022-04-12 15:13:08 +00:00
|
|
|
fvalue_t *
|
2021-11-23 21:20:34 +00:00
|
|
|
dfilter_fvalue_from_charconst(dfwork_t *dfw, ftenum_t ftype, stnode_t *st)
|
2021-11-23 16:02:35 +00:00
|
|
|
{
|
|
|
|
fvalue_t *fvalue;
|
2021-11-23 21:20:34 +00:00
|
|
|
unsigned long *nump = stnode_data(st);
|
2021-11-23 16:02:35 +00:00
|
|
|
|
2021-11-23 21:20:34 +00:00
|
|
|
fvalue = fvalue_from_charconst(ftype, *nump,
|
2021-11-23 16:02:35 +00:00
|
|
|
dfw->error_message == NULL ? &dfw->error_message : NULL);
|
2022-04-07 12:57:39 +00:00
|
|
|
|
|
|
|
if (fvalue == NULL) {
|
|
|
|
dfw_set_error_location(dfw, stnode_location(st));
|
2021-11-23 16:02:35 +00:00
|
|
|
THROW(TypeError);
|
2022-04-07 12:57:39 +00:00
|
|
|
}
|
2021-11-23 16:02:35 +00:00
|
|
|
|
|
|
|
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
|
2021-10-21 08:03:51 +00:00
|
|
|
check_relation_LHS_FIELD(dfwork_t *dfw, test_op_t st_op,
|
2015-01-18 10:22:19 +00:00
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value,
|
2021-11-28 01:10:11 +00:00
|
|
|
stnode_t *st_node,
|
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2011-04-27 04:24:44 +00:00
|
|
|
sttype_id_t type2;
|
2022-04-09 22:03:40 +00:00
|
|
|
header_field_info *hfinfo1;
|
2001-02-01 20:21:25 +00:00
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-02-20 00:14:24 +00:00
|
|
|
again:
|
2001-02-01 20:21:25 +00:00
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
ws_assert(stnode_type_id(st_arg1) == STTYPE_FIELD ||
|
|
|
|
stnode_type_id(st_arg1) == STTYPE_REFERENCE);
|
2021-11-08 12:20:40 +00:00
|
|
|
hfinfo1 = stnode_data(st_arg1);
|
2001-02-27 19:23:30 +00:00
|
|
|
ftype1 = hfinfo1->type;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!can_func(ftype1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "%s (type=%s) cannot participate in %s comparison.",
|
2003-07-25 03:44:05 +00:00
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1),
|
2021-11-28 01:10:11 +00:00
|
|
|
stnode_todisplay(st_node));
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
if (IS_FIELD_ENTITY(type2)) {
|
|
|
|
ftype2 = field_ftenum(st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s and %s are not of compatible types.",
|
2022-04-09 22:03:40 +00:00
|
|
|
hfinfo1->abbrev, stnode_todisplay(st_arg2));
|
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)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s (type=%s) cannot participate in specified comparison.",
|
2022-04-09 22:03:40 +00:00
|
|
|
stnode_todisplay(st_arg2), ftype_pretty_name(ftype2));
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
}
|
2022-02-20 00:14:24 +00:00
|
|
|
else if (type2 == STTYPE_STRING || type2 == STTYPE_LITERAL || type2 == STTYPE_UNPARSED) {
|
2021-10-09 15:40:08 +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;
|
|
|
|
}
|
2014-12-09 17:55:44 +00:00
|
|
|
|
2022-02-20 00:14:24 +00:00
|
|
|
if (type2 == STTYPE_UNPARSED) {
|
2022-04-06 20:59:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype1, st_arg2, allow_partial_value, hfinfo1);
|
|
|
|
if (fvalue == NULL) {
|
|
|
|
/* We have a protocol or protocol field. */
|
2022-02-20 00:14:24 +00:00
|
|
|
goto again;
|
2022-04-06 20:59:02 +00:00
|
|
|
}
|
2022-02-20 00:14:24 +00:00
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_STRING) {
|
2021-10-09 15:40:08 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype1, st_arg2, hfinfo1);
|
|
|
|
}
|
|
|
|
else {
|
2022-02-23 00:47:00 +00:00
|
|
|
fvalue = dfilter_fvalue_from_literal(dfw, ftype1, st_arg2, allow_partial_value, hfinfo1);
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2021-10-09 15:40:08 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
2021-11-23 21:20:34 +00:00
|
|
|
else if (type2 == STTYPE_CHARCONST) {
|
|
|
|
fvalue = dfilter_fvalue_from_charconst(dfw, ftype1, st_arg2);
|
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
|
|
|
}
|
2022-04-11 19:06:49 +00:00
|
|
|
else if (type2 == STTYPE_SLICE) {
|
|
|
|
check_slice_sanity(dfw, st_arg2, ftype1);
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!is_bytes_type(ftype1)) {
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "\"%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));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert entire field to bytes */
|
2021-10-09 00:34:31 +00:00
|
|
|
convert_to_bytes(st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2011-04-27 04:24:44 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
2022-04-16 01:42:20 +00:00
|
|
|
ftype2 = check_function(dfw, st_arg2, ftype1);
|
2009-05-31 19:46:31 +00:00
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%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),
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(st_arg2), ftype_pretty_name(ftype2));
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "return value of %s() (type=%s) cannot participate in specified comparison.",
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(st_arg2), ftype_pretty_name(ftype2));
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
2011-04-27 04:24:44 +00:00
|
|
|
}
|
2021-10-09 15:40:08 +00:00
|
|
|
else if (type2 == STTYPE_PCRE) {
|
2021-10-21 08:03:51 +00:00
|
|
|
ws_assert(st_op == TEST_OP_MATCHES);
|
2021-10-09 15:40:08 +00:00
|
|
|
}
|
2022-02-27 09:56:41 +00:00
|
|
|
else if (type2 == STTYPE_ARITHMETIC) {
|
2022-04-04 15:52:11 +00:00
|
|
|
ftype2 = check_arithmetic_expr(dfw, st_arg2, ftype1);
|
2022-02-27 09:56:41 +00:00
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s and %s are not of compatible types.",
|
2022-02-27 09:56:41 +00:00
|
|
|
stnode_todisplay(st_arg1), stnode_todisplay(st_arg2));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s (type=%s) cannot participate in specified comparison.",
|
2022-02-27 09:56:41 +00:00
|
|
|
stnode_todisplay(st_arg2), ftype_pretty_name(ftype2));
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
static void
|
|
|
|
check_relation_LHS_LAYER(dfwork_t *dfw, test_op_t st_op,
|
|
|
|
FtypeCanFunc can_func,
|
|
|
|
gboolean allow_partial_value,
|
|
|
|
stnode_t *st_node,
|
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *entity;
|
|
|
|
|
|
|
|
check_layer_sanity(dfw, st_arg1);
|
|
|
|
entity = sttype_range_entity(st_arg1);
|
|
|
|
ws_assert(stnode_type_id(entity) == STTYPE_FIELD);
|
|
|
|
check_relation_LHS_FIELD(dfw, st_op, can_func, allow_partial_value, st_node, entity, st_arg2);
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
static void
|
2022-04-11 19:06:49 +00:00
|
|
|
check_relation_LHS_SLICE(dfwork_t *dfw, test_op_t st_op,
|
2015-01-18 10:22:19 +00:00
|
|
|
FtypeCanFunc can_func _U_,
|
2004-01-01 16:59:20 +00:00
|
|
|
gboolean allow_partial_value,
|
2021-10-09 00:34:31 +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;
|
2021-10-05 11:13:15 +00:00
|
|
|
ftenum_t ftype2;
|
2001-02-27 19:23:30 +00:00
|
|
|
fvalue_t *fvalue;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-04-11 19:06:49 +00:00
|
|
|
check_slice_sanity(dfw, st_arg1, FT_NONE);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2022-02-20 00:14:24 +00:00
|
|
|
again:
|
2021-10-05 11:13:15 +00:00
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
if (IS_FIELD_ENTITY(type2)) {
|
|
|
|
ftype2 = field_ftenum(st_arg2);
|
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)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "\"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2022-04-09 22:03:40 +00:00
|
|
|
stnode_todisplay(st_arg2),
|
2001-02-27 19:23:30 +00:00
|
|
|
ftype_pretty_name(ftype2));
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
|
|
|
|
/* Convert entire field to bytes */
|
2021-10-09 00:34:31 +00:00
|
|
|
convert_to_bytes(st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_STRING) {
|
2021-10-09 15:40:08 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, FT_BYTES, st_arg2, NULL);
|
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2022-02-20 00:14:24 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED) {
|
2022-04-06 20:59:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, FT_BYTES, st_arg2, allow_partial_value, NULL);
|
|
|
|
if (fvalue == NULL) {
|
|
|
|
/* We have a protocol or protocol field. */
|
2022-02-20 00:14:24 +00:00
|
|
|
goto again;
|
2022-04-06 20:59:02 +00:00
|
|
|
}
|
2022-02-20 00:14:24 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
|
|
|
}
|
2022-02-23 00:47:00 +00:00
|
|
|
else if (type2 == STTYPE_LITERAL) {
|
|
|
|
fvalue = dfilter_fvalue_from_literal(dfw, FT_BYTES, st_arg2, allow_partial_value, NULL);
|
2021-10-09 15:40:08 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
2021-11-23 16:02:35 +00:00
|
|
|
else if (type2 == STTYPE_CHARCONST) {
|
2021-11-23 21:20:34 +00:00
|
|
|
fvalue = dfilter_fvalue_from_charconst(dfw, FT_BYTES, st_arg2);
|
2021-11-23 16:02:35 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
|
|
|
}
|
2022-04-11 19:06:49 +00:00
|
|
|
else if (type2 == STTYPE_SLICE) {
|
|
|
|
check_slice_sanity(dfw, st_arg2, FT_BYTES);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
2022-04-16 01:42:20 +00:00
|
|
|
ftype2 = check_function(dfw, st_arg2, FT_BYTES);
|
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)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "Return value of function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(st_arg2),
|
2009-05-31 19:46:31 +00:00
|
|
|
ftype_pretty_name(ftype2));
|
|
|
|
}
|
|
|
|
|
2013-07-28 08:41:26 +00:00
|
|
|
/* Convert function result to bytes */
|
2021-10-09 00:34:31 +00:00
|
|
|
convert_to_bytes(st_arg2);
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
|
|
|
}
|
2021-10-09 15:40:08 +00:00
|
|
|
else if (type2 == STTYPE_PCRE) {
|
2021-10-21 08:03:51 +00:00
|
|
|
ws_assert(st_op == TEST_OP_MATCHES);
|
2021-10-09 15:40:08 +00:00
|
|
|
}
|
2022-02-27 09:56:41 +00:00
|
|
|
else if (type2 == STTYPE_ARITHMETIC) {
|
2022-04-04 15:52:11 +00:00
|
|
|
ftype2 = check_arithmetic_expr(dfw, st_arg2, FT_BYTES);
|
2022-02-27 09:56:41 +00:00
|
|
|
|
|
|
|
if (!compatible_ftypes(FT_BYTES, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s and %s are not of compatible types.",
|
2022-02-27 09:56:41 +00:00
|
|
|
stnode_todisplay(st_arg1), stnode_todisplay(st_arg2));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s (type=%s) cannot participate in specified comparison.",
|
2022-02-27 09:56:41 +00:00
|
|
|
stnode_todisplay(st_arg2), ftype_pretty_name(ftype2));
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
/* If the LHS of a relation test is a FUNCTION, run some checks
|
|
|
|
* and possibly some modifications of syntax tree nodes. */
|
|
|
|
static void
|
2021-10-21 08:03:51 +00:00
|
|
|
check_relation_LHS_FUNCTION(dfwork_t *dfw, test_op_t st_op,
|
2021-11-28 01:10:11 +00:00
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value,
|
|
|
|
stnode_t *st_node,
|
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
2006-05-02 14:26:17 +00:00
|
|
|
{
|
|
|
|
sttype_id_t type2;
|
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-04-16 01:42:20 +00:00
|
|
|
ftype1 = check_function(dfw, st_arg1, FT_NONE);
|
2006-05-02 14:26:17 +00:00
|
|
|
|
|
|
|
if (!can_func(ftype1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "Function %s (type=%s) cannot participate in %s comparison.",
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(st_arg1), ftype_pretty_name(ftype1),
|
2021-11-28 01:10:11 +00:00
|
|
|
stnode_todisplay(st_node));
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
|
2022-02-20 00:14:24 +00:00
|
|
|
again:
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
if (IS_FIELD_ENTITY(type2)) {
|
|
|
|
ftype2 = field_ftenum(st_arg2);
|
2006-05-02 14:26:17 +00:00
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "Function %s and %s are not of compatible types.",
|
2022-04-09 22:03:40 +00:00
|
|
|
sttype_function_name(st_arg2), stnode_todisplay(st_arg2));
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
/* Do this check even though you'd think that if
|
|
|
|
* they're compatible, then can_func() would pass. */
|
|
|
|
if (!can_func(ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s (type=%s) cannot participate in specified comparison.",
|
2022-04-09 22:03:40 +00:00
|
|
|
stnode_todisplay(st_arg2), ftype_pretty_name(ftype2));
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_STRING) {
|
2021-10-09 15:40:08 +00:00
|
|
|
fvalue = dfilter_fvalue_from_string(dfw, ftype1, st_arg2, NULL);
|
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
2022-02-20 00:14:24 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED) {
|
2022-04-06 20:59:02 +00:00
|
|
|
fvalue = dfilter_fvalue_from_unparsed(dfw, ftype1, st_arg2, allow_partial_value, NULL);
|
|
|
|
if (fvalue == NULL) {
|
|
|
|
/* We have a protocol or protocol field. */
|
2022-02-20 00:14:24 +00:00
|
|
|
goto again;
|
2022-04-06 20:59:02 +00:00
|
|
|
}
|
2022-02-20 00:14:24 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
|
|
|
}
|
2022-02-23 00:47:00 +00:00
|
|
|
else if (type2 == STTYPE_LITERAL) {
|
|
|
|
fvalue = dfilter_fvalue_from_literal(dfw, ftype1, st_arg2, allow_partial_value, NULL);
|
2021-10-09 15:40:08 +00:00
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
2021-11-23 21:20:34 +00:00
|
|
|
else if (type2 == STTYPE_CHARCONST) {
|
|
|
|
fvalue = dfilter_fvalue_from_charconst(dfw, ftype1, st_arg2);
|
|
|
|
stnode_replace(st_arg2, STTYPE_FVALUE, fvalue);
|
|
|
|
}
|
2022-04-11 19:06:49 +00:00
|
|
|
else if (type2 == STTYPE_SLICE) {
|
|
|
|
check_slice_sanity(dfw, st_arg2, ftype1);
|
2006-05-02 14:26:17 +00:00
|
|
|
if (!is_bytes_type(ftype1)) {
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "Function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(st_arg1),
|
2006-05-02 14:26:17 +00:00
|
|
|
ftype_pretty_name(ftype1));
|
|
|
|
}
|
|
|
|
|
2013-07-28 08:41:26 +00:00
|
|
|
/* Convert function result to bytes */
|
2021-10-09 00:34:31 +00:00
|
|
|
convert_to_bytes(st_arg1);
|
2006-05-02 14:26:17 +00:00
|
|
|
}
|
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
2022-04-16 01:42:20 +00:00
|
|
|
ftype2 = check_function(dfw, st_arg2, ftype1);
|
2009-05-31 19:46:31 +00:00
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "Return values of function %s (type=%s) and function %s (type=%s) are not of compatible types.",
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(st_arg1), ftype_pretty_name(ftype1), sttype_function_name(st_arg1), ftype_pretty_name(ftype2));
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Do this check even though you'd think that if
|
|
|
|
* they're compatible, then can_func() would pass. */
|
|
|
|
if (!can_func(ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "Return value of %s (type=%s) cannot participate in specified comparison.",
|
2022-04-12 15:13:08 +00:00
|
|
|
sttype_function_name(st_arg2), ftype_pretty_name(ftype2));
|
2009-05-31 19:46:31 +00:00
|
|
|
}
|
|
|
|
}
|
2021-10-09 15:40:08 +00:00
|
|
|
else if (type2 == STTYPE_PCRE) {
|
2021-10-21 08:03:51 +00:00
|
|
|
ws_assert(st_op == TEST_OP_MATCHES);
|
2021-10-09 15:40:08 +00:00
|
|
|
}
|
2022-02-27 09:56:41 +00:00
|
|
|
else if (type2 == STTYPE_ARITHMETIC) {
|
2022-04-04 15:52:11 +00:00
|
|
|
ftype2 = check_arithmetic_expr(dfw, st_arg2, ftype1);
|
2022-02-27 09:56:41 +00:00
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s and %s are not of compatible types.",
|
2022-02-27 09:56:41 +00:00
|
|
|
stnode_todisplay(st_arg1), stnode_todisplay(st_arg2));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s (type=%s) cannot participate in specified comparison.",
|
2022-02-27 09:56:41 +00:00
|
|
|
stnode_todisplay(st_arg2), ftype_pretty_name(ftype2));
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-27 09:56:41 +00:00
|
|
|
static void
|
|
|
|
check_relation_LHS_ARITHMETIC(dfwork_t *dfw, test_op_t st_op _U_,
|
|
|
|
FtypeCanFunc can_func _U_, gboolean allow_partial_value,
|
2022-04-01 12:32:16 +00:00
|
|
|
stnode_t *st_node, stnode_t *st_arg1, stnode_t *st_arg2)
|
2022-02-27 09:56:41 +00:00
|
|
|
{
|
|
|
|
stnode_t *entity;
|
|
|
|
sttype_id_t entity_type;
|
|
|
|
|
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-04-04 15:52:11 +00:00
|
|
|
check_arithmetic_expr(dfw, st_arg1, FT_NONE);
|
2022-04-01 12:32:16 +00:00
|
|
|
|
2022-02-27 09:56:41 +00:00
|
|
|
sttype_test_get(st_arg1, NULL, &entity, NULL);
|
|
|
|
entity_type = stnode_type_id(entity);
|
|
|
|
|
2022-04-09 22:03:40 +00:00
|
|
|
if (IS_FIELD_ENTITY(entity_type)) {
|
2022-02-27 09:56:41 +00:00
|
|
|
check_relation_LHS_FIELD(dfw, st_op, can_func, allow_partial_value, st_node, entity, st_arg2);
|
|
|
|
}
|
|
|
|
else if (entity_type == STTYPE_FUNCTION) {
|
|
|
|
check_relation_LHS_FUNCTION(dfw, st_op, can_func, allow_partial_value, st_node, entity, st_arg2);
|
|
|
|
}
|
2022-04-11 19:06:49 +00:00
|
|
|
else if (entity_type == STTYPE_SLICE) {
|
|
|
|
check_relation_LHS_SLICE(dfw, st_op, can_func, allow_partial_value, st_node, entity, st_arg2);
|
2022-04-03 21:49:16 +00:00
|
|
|
}
|
2022-04-04 15:52:11 +00:00
|
|
|
else if (entity_type == STTYPE_ARITHMETIC) {
|
|
|
|
check_relation_LHS_ARITHMETIC(dfw, st_op, can_func, allow_partial_value, st_node, entity, st_arg2);
|
|
|
|
}
|
2022-02-27 09:56:41 +00:00
|
|
|
else {
|
2022-04-01 12:32:16 +00:00
|
|
|
ws_assert_not_reached();
|
2022-02-27 09:56:41 +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
|
2021-10-21 08:03:51 +00:00
|
|
|
check_relation(dfwork_t *dfw, test_op_t st_op,
|
2021-11-07 23:14:59 +00:00
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value,
|
|
|
|
stnode_t *st_node, stnode_t *st_arg1, stnode_t *st_arg2)
|
2001-02-27 19:23:30 +00:00
|
|
|
{
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, st_arg1);
|
2022-02-20 00:14:24 +00:00
|
|
|
|
2021-11-07 22:33:43 +00:00
|
|
|
switch (stnode_type_id(st_arg1)) {
|
|
|
|
case STTYPE_FIELD:
|
2022-03-27 14:26:46 +00:00
|
|
|
case STTYPE_REFERENCE:
|
2021-11-07 22:33:43 +00:00
|
|
|
check_relation_LHS_FIELD(dfw, st_op, can_func,
|
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2022-04-09 22:03:40 +00:00
|
|
|
case STTYPE_LAYER:
|
|
|
|
check_relation_LHS_LAYER(dfw, st_op, can_func,
|
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2022-04-11 19:06:49 +00:00
|
|
|
case STTYPE_SLICE:
|
|
|
|
check_relation_LHS_SLICE(dfw, st_op, can_func,
|
2021-11-07 22:33:43 +00:00
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
|
|
|
case STTYPE_FUNCTION:
|
|
|
|
check_relation_LHS_FUNCTION(dfw, st_op, can_func,
|
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2022-02-27 09:56:41 +00:00
|
|
|
case STTYPE_ARITHMETIC:
|
|
|
|
check_relation_LHS_ARITHMETIC(dfw, st_op, can_func,
|
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2021-11-07 22:33:43 +00:00
|
|
|
default:
|
2022-04-09 22:03:40 +00:00
|
|
|
FAIL(dfw, st_arg1, "Left side of \"%s\" expression must be a field or function, not %s.",
|
2022-02-27 22:40:17 +00:00
|
|
|
stnode_todisplay(st_node), stnode_todisplay(st_arg1));
|
2021-11-07 22:33:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_relation_contains(dfwork_t *dfw, stnode_t *st_node,
|
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, st_arg1);
|
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:
|
2022-03-27 14:26:46 +00:00
|
|
|
case STTYPE_REFERENCE:
|
2021-11-07 22:33:43 +00:00
|
|
|
check_relation_LHS_FIELD(dfw, TEST_OP_CONTAINS, ftype_can_contains,
|
|
|
|
TRUE, st_node, st_arg1, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
break;
|
2021-11-07 22:33:43 +00:00
|
|
|
case STTYPE_FUNCTION:
|
|
|
|
check_relation_LHS_FUNCTION(dfw, TEST_OP_CONTAINS, ftype_can_contains,
|
|
|
|
TRUE, st_node, st_arg1, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
break;
|
2022-04-11 19:06:49 +00:00
|
|
|
case STTYPE_SLICE:
|
|
|
|
check_relation_LHS_SLICE(dfw, TEST_OP_CONTAINS, ftype_can_contains,
|
2021-11-07 22:33:43 +00:00
|
|
|
TRUE, st_node, st_arg1, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
break;
|
2011-04-27 04:24:44 +00:00
|
|
|
default:
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "Left side of %s expression must be a field or function, not %s.",
|
2022-02-27 22:40:17 +00:00
|
|
|
stnode_todisplay(st_node), stnode_todisplay(st_arg1));
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-27 22:40:17 +00:00
|
|
|
|
2021-10-27 23:38:38 +00:00
|
|
|
static void
|
|
|
|
check_relation_matches(dfwork_t *dfw, stnode_t *st_node,
|
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
2021-11-12 15:55:14 +00:00
|
|
|
ws_regex_t *pcre;
|
2021-11-05 06:13:29 +00:00
|
|
|
char *errmsg = NULL;
|
2022-06-18 09:43:24 +00:00
|
|
|
GString *patt;
|
2021-11-05 06:13:29 +00:00
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, st_arg1);
|
2022-02-20 00:14:24 +00:00
|
|
|
|
2021-11-05 06:13:29 +00:00
|
|
|
if (stnode_type_id(st_arg2) != STTYPE_STRING) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "Matches requires a double quoted string on the right side.");
|
2021-11-05 06:13:29 +00:00
|
|
|
}
|
|
|
|
|
2022-06-18 09:43:24 +00:00
|
|
|
patt = stnode_string(st_arg2);
|
|
|
|
ws_debug("Compile regex pattern: %s", stnode_token(st_arg2));
|
2021-11-05 06:13:29 +00:00
|
|
|
|
2022-06-18 09:43:24 +00:00
|
|
|
pcre = ws_regex_compile_ex(patt->str, patt->len, &errmsg, WS_REGEX_CASELESS|WS_REGEX_NEVER_UTF);
|
2021-11-05 06:13:29 +00:00
|
|
|
if (errmsg) {
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, NULL, "Regex compilation error: %s.", errmsg);
|
2021-11-05 06:13:29 +00:00
|
|
|
g_free(errmsg);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
stnode_replace(st_arg2, STTYPE_PCRE, pcre);
|
|
|
|
|
2021-11-07 22:33:43 +00:00
|
|
|
switch (stnode_type_id(st_arg1)) {
|
|
|
|
case STTYPE_FIELD:
|
2022-03-27 14:26:46 +00:00
|
|
|
case STTYPE_REFERENCE:
|
2021-11-07 22:33:43 +00:00
|
|
|
check_relation_LHS_FIELD(dfw, TEST_OP_MATCHES, ftype_can_matches,
|
|
|
|
TRUE, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
|
|
|
case STTYPE_FUNCTION:
|
|
|
|
check_relation_LHS_FUNCTION(dfw, TEST_OP_MATCHES, ftype_can_matches,
|
|
|
|
TRUE, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2022-04-11 19:06:49 +00:00
|
|
|
case STTYPE_SLICE:
|
|
|
|
check_relation_LHS_SLICE(dfw, TEST_OP_MATCHES, ftype_can_matches,
|
2021-11-07 22:33:43 +00:00
|
|
|
TRUE, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
|
|
|
default:
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "Left side of %s expression must be a field or function, not %s.",
|
2022-02-27 22:40:17 +00:00
|
|
|
stnode_todisplay(st_node), stnode_todisplay(st_arg1));
|
2021-10-27 23:38:38 +00:00
|
|
|
}
|
2021-11-07 22:33:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_relation_in(dfwork_t *dfw, stnode_t *st_node _U_,
|
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
GSList *nodelist;
|
2021-11-28 01:10:11 +00:00
|
|
|
stnode_t *node_left, *node_right;
|
2021-11-07 22:33:43 +00:00
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, st_arg1);
|
2022-02-20 00:14:24 +00:00
|
|
|
|
2021-11-07 22:33:43 +00:00
|
|
|
if (stnode_type_id(st_arg1) != STTYPE_FIELD) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "Only a field may be tested for membership in a set.");
|
2021-10-27 23:38:38 +00:00
|
|
|
}
|
2021-11-07 22:33:43 +00:00
|
|
|
/* Checked in the grammar parser. */
|
|
|
|
ws_assert(stnode_type_id(st_arg2) == STTYPE_SET);
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
nodelist = stnode_data(st_arg2);
|
|
|
|
while (nodelist) {
|
2021-11-28 01:10:11 +00:00
|
|
|
node_left = nodelist->data;
|
2021-11-07 22:33:43 +00:00
|
|
|
|
|
|
|
/* Don't let a range on the RHS affect the LHS field. */
|
2022-04-11 19:06:49 +00:00
|
|
|
if (stnode_type_id(node_left) == STTYPE_SLICE) {
|
|
|
|
FAIL(dfw, node_left, "A slice may not appear inside a set.");
|
2021-11-07 22:33:43 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nodelist = g_slist_next(nodelist);
|
|
|
|
ws_assert(nodelist);
|
|
|
|
node_right = nodelist->data;
|
|
|
|
if (node_right) {
|
|
|
|
check_relation_LHS_FIELD(dfw, TEST_OP_GE, ftype_can_cmp,
|
2021-11-28 01:10:11 +00:00
|
|
|
FALSE, st_node, st_arg1, node_left);
|
2021-11-07 22:33:43 +00:00
|
|
|
check_relation_LHS_FIELD(dfw, TEST_OP_LE, ftype_can_cmp,
|
2021-11-28 01:10:11 +00:00
|
|
|
FALSE, st_node, st_arg1, node_right);
|
2021-11-07 22:33:43 +00:00
|
|
|
} else {
|
|
|
|
check_relation_LHS_FIELD(dfw, TEST_OP_ANY_EQ, ftype_can_eq,
|
2021-11-28 01:10:11 +00:00
|
|
|
FALSE, st_node, st_arg1, node_left);
|
2021-11-07 22:33:43 +00:00
|
|
|
}
|
|
|
|
nodelist = g_slist_next(nodelist);
|
|
|
|
}
|
2021-10-27 23:38:38 +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
|
|
|
{
|
2022-03-27 23:35:19 +00:00
|
|
|
test_op_t st_op;
|
2001-02-01 20:21:25 +00:00
|
|
|
stnode_t *st_arg1, *st_arg2;
|
2003-12-09 23:02:40 +00:00
|
|
|
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(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_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:
|
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;
|
|
|
|
|
2021-12-13 01:06:01 +00:00
|
|
|
case TEST_OP_ALL_EQ:
|
dfilter: Fix "!=" relation to be free of contradictions
Wireshark defines the relation of equality A == B as
A any_eq B <=> An == Bn for at least one An, Bn.
More accurately I think this is (formally) an equivalence
relation, not true equality.
Whichever definition for "==" we choose we must keep the
definition of "!=" as !(A == B), otherwise it will
lead to logical contradictions like (A == B) AND (A != B)
being true.
Fix the '!=' relation to match the definition of equality:
A != B <=> !(A == B) <=> A all_ne B <=> An != Bn, for
every n.
This has been the recomended way to write "not equal" for a
long time in the documentation, even to the point where != was
deprecated, but it just wasn't implemented consistently in the
language, which has understandably been a persistent source
of confusion. Even a field that is normally well-behaved
with "!=" like "ip.src" or "ip.dst" will produce unexpected
results with encapsulations like IP-over-IP.
The opcode ALL_NE could have been implemented in the compiler
instead using NOT and ANY_EQ but I chose to implement it in
bytecode. It just seemed more elegant and efficient
but the difference was not very significant.
Keep around "~=" for any_ne relation, in case someone depends
on that, and because we don't have an operator for true equality:
A strict_equal B <=> A all_eq B <=> !(A any_ne B).
If there is only one value then any_ne and all_ne are the same
comparison operation.
Implementing this change did not require fixing any tests so it
is unlikely the relation "~=" (any_ne) will be very useful.
Note that the behaviour of the '<' (less than) comparison relation
is a separate, more subtle issue. In the general case the definition
of '<' that is used is only a partial order.
2021-10-18 20:07:06 +00:00
|
|
|
case TEST_OP_ANY_EQ:
|
|
|
|
case TEST_OP_ALL_NE:
|
|
|
|
case TEST_OP_ANY_NE:
|
2021-11-07 23:14:59 +00:00
|
|
|
check_relation(dfw, st_op, ftype_can_eq, FALSE, st_node, st_arg1, st_arg2);
|
dfilter: Fix "!=" relation to be free of contradictions
Wireshark defines the relation of equality A == B as
A any_eq B <=> An == Bn for at least one An, Bn.
More accurately I think this is (formally) an equivalence
relation, not true equality.
Whichever definition for "==" we choose we must keep the
definition of "!=" as !(A == B), otherwise it will
lead to logical contradictions like (A == B) AND (A != B)
being true.
Fix the '!=' relation to match the definition of equality:
A != B <=> !(A == B) <=> A all_ne B <=> An != Bn, for
every n.
This has been the recomended way to write "not equal" for a
long time in the documentation, even to the point where != was
deprecated, but it just wasn't implemented consistently in the
language, which has understandably been a persistent source
of confusion. Even a field that is normally well-behaved
with "!=" like "ip.src" or "ip.dst" will produce unexpected
results with encapsulations like IP-over-IP.
The opcode ALL_NE could have been implemented in the compiler
instead using NOT and ANY_EQ but I chose to implement it in
bytecode. It just seemed more elegant and efficient
but the difference was not very significant.
Keep around "~=" for any_ne relation, in case someone depends
on that, and because we don't have an operator for true equality:
A strict_equal B <=> A all_eq B <=> !(A any_ne B).
If there is only one value then any_ne and all_ne are the same
comparison operation.
Implementing this change did not require fixing any tests so it
is unlikely the relation "~=" (any_ne) will be very useful.
Note that the behaviour of the '<' (less than) comparison relation
is a separate, more subtle issue. In the general case the definition
of '<' that is used is only a partial order.
2021-10-18 20:07:06 +00:00
|
|
|
break;
|
2001-02-01 20:21:25 +00:00
|
|
|
case TEST_OP_GT:
|
|
|
|
case TEST_OP_GE:
|
|
|
|
case TEST_OP_LT:
|
|
|
|
case TEST_OP_LE:
|
2021-11-07 23:14:59 +00:00
|
|
|
check_relation(dfw, st_op, ftype_can_cmp, FALSE, st_node, st_arg1, st_arg2);
|
2003-08-27 15:23:11 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_CONTAINS:
|
2021-11-07 22:33:43 +00:00
|
|
|
check_relation_contains(dfw, 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:
|
2021-10-27 23:38:38 +00:00
|
|
|
check_relation_matches(dfw, st_node, st_arg1, st_arg2);
|
2015-08-19 03:03:41 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_IN:
|
2021-11-07 22:33:43 +00:00
|
|
|
check_relation_in(dfw, st_node, st_arg1, st_arg2);
|
2015-08-19 03:03:41 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-27 09:56:41 +00:00
|
|
|
ftenum_t
|
2022-04-04 15:52:11 +00:00
|
|
|
check_arithmetic_entity(dfwork_t *dfw, stnode_t *st_arg, ftenum_t lhs_ftype)
|
2022-02-27 09:56:41 +00:00
|
|
|
{
|
|
|
|
sttype_id_t type;
|
|
|
|
ftenum_t ftype;
|
|
|
|
|
2022-04-04 15:52:11 +00:00
|
|
|
LOG_NODE(st_arg);
|
|
|
|
|
2022-04-01 12:32:16 +00:00
|
|
|
/* lhs_ftype variable determines the type for this entity. If LHS type
|
|
|
|
* is none we must have been passed an entity with a definite type
|
|
|
|
* (field, function, etc). */
|
|
|
|
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, st_arg);
|
2022-02-27 09:56:41 +00:00
|
|
|
type = stnode_type_id(st_arg);
|
|
|
|
|
|
|
|
if (type == STTYPE_LITERAL) {
|
|
|
|
/* numeric constant */
|
|
|
|
ws_assert(lhs_ftype != FT_NONE);
|
|
|
|
fvalue_t *fvalue = dfilter_fvalue_from_literal(dfw, lhs_ftype, st_arg, FALSE, NULL);
|
|
|
|
stnode_replace(st_arg, STTYPE_FVALUE, fvalue);
|
|
|
|
ftype = fvalue_type_ftenum(fvalue);
|
|
|
|
}
|
2022-03-27 14:26:46 +00:00
|
|
|
else if (type == STTYPE_FIELD || type == STTYPE_REFERENCE) {
|
2022-02-27 09:56:41 +00:00
|
|
|
header_field_info *hfinfo = stnode_data(st_arg);
|
|
|
|
ftype = hfinfo->type;
|
|
|
|
}
|
|
|
|
else if (type == STTYPE_FUNCTION) {
|
2022-04-16 01:42:20 +00:00
|
|
|
ftype = check_function(dfw, st_arg, lhs_ftype);
|
2022-02-27 09:56:41 +00:00
|
|
|
}
|
2022-04-11 19:06:49 +00:00
|
|
|
else if (type == STTYPE_SLICE) {
|
|
|
|
check_slice_sanity(dfw, st_arg, lhs_ftype);
|
2022-04-03 21:49:16 +00:00
|
|
|
|
|
|
|
ftype = FT_BYTES;
|
|
|
|
}
|
2022-04-04 15:52:11 +00:00
|
|
|
else if (type == STTYPE_FVALUE) {
|
|
|
|
ftype = fvalue_type_ftenum(stnode_data(st_arg));
|
|
|
|
}
|
2022-02-27 09:56:41 +00:00
|
|
|
else {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg, "%s is not a valid arithmetic operand.",
|
2022-04-04 15:52:11 +00:00
|
|
|
stnode_todisplay(st_arg));
|
2022-02-27 09:56:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ftype;
|
|
|
|
}
|
|
|
|
|
2022-02-27 14:47:31 +00:00
|
|
|
ftenum_t
|
2022-04-04 15:52:11 +00:00
|
|
|
check_arithmetic_expr(dfwork_t *dfw, stnode_t *st_node, ftenum_t lhs_ftype)
|
2022-02-27 14:47:31 +00:00
|
|
|
{
|
|
|
|
test_op_t st_op;
|
|
|
|
stnode_t *st_arg1, *st_arg2;
|
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
FtypeCanFunc can_func = NULL;
|
|
|
|
|
2022-04-04 15:52:11 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
|
|
|
if (stnode_type_id(st_node) != STTYPE_ARITHMETIC) {
|
|
|
|
return check_arithmetic_entity(dfw, st_node, lhs_ftype);
|
|
|
|
}
|
|
|
|
|
2022-02-27 14:47:31 +00:00
|
|
|
sttype_test_get(st_node, &st_op, &st_arg1, &st_arg2);
|
2022-04-12 15:13:08 +00:00
|
|
|
dfw_resolve_unparsed(dfw, st_arg1);
|
2022-04-01 17:44:15 +00:00
|
|
|
|
|
|
|
/* On the LHS we require a field-like value as the first term. */
|
|
|
|
if (lhs_ftype == FT_NONE && node_is_constant(st_arg1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "Constant arithmetic expression on the LHS is invalid.");
|
2022-04-01 17:44:15 +00:00
|
|
|
}
|
2022-02-27 14:47:31 +00:00
|
|
|
|
2022-04-04 15:52:11 +00:00
|
|
|
if (st_op == OP_UNARY_MINUS) {
|
|
|
|
ftype1 = check_arithmetic_entity(dfw, st_arg1, lhs_ftype);
|
|
|
|
if (stnode_type_id(st_arg1) == STTYPE_FVALUE) {
|
|
|
|
/* Pre-compute constant unary minus result */
|
|
|
|
char *err_msg;
|
|
|
|
fvalue_t *new_fv = fvalue_unary_minus(stnode_data(st_arg1), &err_msg);
|
|
|
|
if (new_fv == NULL) {
|
2022-04-07 12:57:39 +00:00
|
|
|
dfilter_fail(dfw, stnode_location(st_arg1),
|
|
|
|
"%s: %s", stnode_todisplay(st_arg1), err_msg);
|
2022-04-04 15:52:11 +00:00
|
|
|
g_free(err_msg);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
/* Replaces unary operator with result */
|
|
|
|
stnode_replace(st_node, STTYPE_FVALUE, new_fv);
|
|
|
|
}
|
|
|
|
return ftype1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ftype1 = check_arithmetic_expr(dfw, st_arg1, lhs_ftype);
|
|
|
|
ftype2 = check_arithmetic_expr(dfw, st_arg2, ftype1);
|
|
|
|
|
2022-02-27 14:47:31 +00:00
|
|
|
switch (st_op) {
|
|
|
|
case OP_ADD:
|
|
|
|
can_func = ftype_can_add;
|
|
|
|
break;
|
|
|
|
case OP_SUBTRACT:
|
|
|
|
can_func = ftype_can_subtract;
|
|
|
|
break;
|
2022-03-31 13:50:20 +00:00
|
|
|
case OP_MULTIPLY:
|
|
|
|
can_func = ftype_can_multiply;
|
|
|
|
break;
|
|
|
|
case OP_DIVIDE:
|
|
|
|
can_func = ftype_can_divide;
|
|
|
|
break;
|
|
|
|
case OP_MODULO:
|
|
|
|
can_func = ftype_can_modulo;
|
|
|
|
break;
|
2022-04-03 21:49:16 +00:00
|
|
|
case OP_BITWISE_AND:
|
|
|
|
can_func = ftype_can_bitwise_and;
|
|
|
|
break;
|
2022-02-27 14:47:31 +00:00
|
|
|
default:
|
|
|
|
ws_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2022-04-04 15:52:11 +00:00
|
|
|
if (!can_func(ftype1)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg1, "%s cannot %s.",
|
2022-04-04 15:52:11 +00:00
|
|
|
ftype_name(ftype1), stnode_todisplay(st_node));
|
|
|
|
}
|
|
|
|
if (!can_func(ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s cannot %s.",
|
2022-04-04 15:52:11 +00:00
|
|
|
ftype_name(ftype2), stnode_todisplay(st_node));
|
|
|
|
}
|
2022-02-27 14:47:31 +00:00
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
2022-04-07 12:57:39 +00:00
|
|
|
FAIL(dfw, st_arg2, "%s and %s are not type compatible.",
|
2022-02-27 14:47:31 +00:00
|
|
|
stnode_todisplay(st_arg1), stnode_todisplay(st_arg2));
|
|
|
|
}
|
2022-04-04 15:52:11 +00:00
|
|
|
|
2022-02-27 14:47:31 +00:00
|
|
|
return ftype1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
|
|
{
|
2022-02-27 14:11:50 +00:00
|
|
|
LOG_NODE(st_node);
|
|
|
|
|
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;
|
2022-04-04 10:33:38 +00:00
|
|
|
case STTYPE_ARITHMETIC:
|
2022-04-04 15:52:11 +00:00
|
|
|
check_arithmetic_expr(dfw, st_node, FT_NONE);
|
2022-04-04 10:33:38 +00:00
|
|
|
break;
|
2022-04-09 22:03:40 +00:00
|
|
|
case STTYPE_LAYER:
|
|
|
|
check_exists_layer(dfw, st_node);
|
|
|
|
break;
|
2001-02-01 20:21:25 +00:00
|
|
|
default:
|
2022-04-04 10:33:38 +00:00
|
|
|
check_exists(dfw, st_node);
|
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;
|
2009-12-18 01:15:08 +00:00
|
|
|
|
2022-03-28 16:19:47 +00:00
|
|
|
ws_noisy("Starting semantic check (dfw = %p)", dfw);
|
2021-09-26 15:28:39 +00:00
|
|
|
|
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;
|
|
|
|
|
2022-03-28 16:19:47 +00:00
|
|
|
ws_noisy("Semantic check (dfw = %p) returns %s",
|
2021-11-15 09:46:47 +00:00
|
|
|
dfw, ok_filter ? "TRUE" : "FALSE");
|
|
|
|
|
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:
|
|
|
|
*/
|