2001-02-01 20:31:21 +00:00
|
|
|
/*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
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
|
|
|
*
|
2001-02-01 20:31:21 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2001-02-01 20:31:21 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2001-02-01 20:31:21 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#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"
|
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
|
|
|
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
/* Enable debug logging by defining AM_CFLAGS
|
|
|
|
* so that it contains "-DDEBUG_dfilter".
|
|
|
|
* Usage: DebugLog(("Error: string=%s\n", str)); */
|
2007-04-17 15:13:17 +00:00
|
|
|
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
#define DebugLog(x) \
|
|
|
|
printf("%s:%u: ", __FILE__, __LINE__); \
|
|
|
|
printf x; \
|
|
|
|
fflush(stdout)
|
|
|
|
#else
|
|
|
|
#define DebugLog(x) ;
|
|
|
|
#endif
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2002-02-27 18:54:33 +00:00
|
|
|
semcheck(stnode_t *st_node);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
static stnode_t*
|
|
|
|
check_param_entity(stnode_t *st_node);
|
|
|
|
|
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:
|
|
|
|
case FT_IPv4:
|
|
|
|
case FT_IPv6:
|
|
|
|
case FT_IPXNET:
|
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 */
|
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:
|
|
|
|
return (b == FT_ETHER || b == FT_BYTES || b == FT_UINT_BYTES || b == FT_GUID || b == FT_OID);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
case FT_BOOLEAN:
|
2002-12-19 02:58:53 +00:00
|
|
|
case FT_FRAMENUM:
|
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:
|
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:
|
2007-11-19 21:27:01 +00:00
|
|
|
case FT_EBCDIC:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT_STRING:
|
|
|
|
switch (b) {
|
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
|
|
|
case FT_UINT_STRING:
|
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2003-12-09 23:02:40 +00:00
|
|
|
case FT_PCRE:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert_not_reached();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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*
|
|
|
|
mk_fvalue_from_val_string(header_field_info *hfinfo, char *s)
|
|
|
|
{
|
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:
|
|
|
|
case FT_ABSOLUTE_TIME:
|
|
|
|
case FT_RELATIVE_TIME:
|
|
|
|
case FT_IPv4:
|
|
|
|
case FT_IPv6:
|
|
|
|
case FT_IPXNET:
|
|
|
|
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:
|
2007-11-19 21:27:01 +00:00
|
|
|
case FT_EBCDIC:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT_STRING:
|
2001-11-02 10:09:51 +00:00
|
|
|
case FT_UINT64:
|
|
|
|
case FT_INT64:
|
2003-12-09 23:02:40 +00:00
|
|
|
case FT_PCRE:
|
2005-07-04 13:04:53 +00:00
|
|
|
case FT_GUID:
|
2005-12-02 13:16:58 +00:00
|
|
|
case FT_OID:
|
2009-07-03 01:11:23 +00:00
|
|
|
return NULL;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
case FT_BOOLEAN:
|
2002-12-19 02:58:53 +00:00
|
|
|
case FT_FRAMENUM:
|
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:
|
|
|
|
break;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset the dfilter error message, since *something* interesting
|
|
|
|
* will happen, and the error message will be more interesting than
|
|
|
|
* any error message I happen to have now. */
|
|
|
|
dfilter_error_msg = NULL;
|
|
|
|
|
|
|
|
/* TRUE/FALSE *always* exist for FT_BOOLEAN. */
|
|
|
|
if (hfinfo->type == FT_BOOLEAN) {
|
|
|
|
if (hfinfo->strings) {
|
|
|
|
tf = hfinfo->strings;
|
|
|
|
}
|
|
|
|
|
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) {
|
2001-02-01 20:21:25 +00:00
|
|
|
return mk_uint32_fvalue(TRUE);
|
|
|
|
}
|
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) {
|
2001-02-01 20:21:25 +00:00
|
|
|
return mk_uint32_fvalue(FALSE);
|
|
|
|
}
|
|
|
|
else {
|
2003-07-25 03:44:05 +00:00
|
|
|
dfilter_fail("\"%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) {
|
|
|
|
dfilter_fail("%s cannot accept strings as values.",
|
|
|
|
hfinfo->abbrev);
|
2009-07-03 01:11:23 +00:00
|
|
|
return NULL;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2009-07-03 01:11:23 +00:00
|
|
|
if (hfinfo->display & BASE_RANGE_STRING) {
|
|
|
|
dfilter_fail("\"%s\" cannot accept [range] strings as values.",
|
|
|
|
hfinfo->abbrev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
const value_string *vals = hfinfo->strings;
|
|
|
|
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
|
|
|
}
|
2009-07-03 01:11:23 +00:00
|
|
|
dfilter_fail("\"%s\" cannot be found among the possible values for %s.",
|
|
|
|
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) {
|
|
|
|
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:
|
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:
|
|
|
|
case FT_ABSOLUTE_TIME:
|
|
|
|
case FT_RELATIVE_TIME:
|
|
|
|
case FT_IPv4:
|
|
|
|
case FT_IPXNET:
|
|
|
|
case FT_STRING:
|
|
|
|
case FT_STRINGZ:
|
2007-11-19 21:27:01 +00:00
|
|
|
case FT_EBCDIC:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT_STRING:
|
|
|
|
case FT_BOOLEAN:
|
2002-12-19 02:58:53 +00:00
|
|
|
case FT_FRAMENUM:
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_UINT8:
|
|
|
|
case FT_UINT16:
|
|
|
|
case FT_UINT24:
|
|
|
|
case FT_UINT32:
|
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:
|
2001-11-02 10:09:51 +00:00
|
|
|
case FT_INT64:
|
2003-12-09 23:02:40 +00:00
|
|
|
case FT_PCRE:
|
2001-02-01 20:21:25 +00:00
|
|
|
return FALSE;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
case FT_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert_not_reached();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2004-02-11 21:20:52 +00:00
|
|
|
/* Check the semantics of an existence test. */
|
|
|
|
static void
|
|
|
|
check_exists(stnode_t *st_arg1)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
DebugLog((" 4 check_exists() [%u]\n", i++));
|
|
|
|
switch (stnode_type_id(st_arg1)) {
|
|
|
|
case STTYPE_FIELD:
|
|
|
|
/* This is OK */
|
|
|
|
break;
|
|
|
|
case STTYPE_STRING:
|
|
|
|
case STTYPE_UNPARSED:
|
|
|
|
dfilter_fail("\"%s\" is neither a field nor a protocol name.",
|
|
|
|
stnode_data(st_arg1));
|
|
|
|
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"?
|
|
|
|
*/
|
|
|
|
dfilter_fail("You cannot test whether a range is present.");
|
|
|
|
THROW(TypeError);
|
|
|
|
break;
|
|
|
|
|
2006-05-02 14:26:17 +00:00
|
|
|
case STTYPE_FUNCTION:
|
|
|
|
/* XXX - Maybe we should change functions so they can return fields,
|
|
|
|
* in which case the 'exist' should be fine. */
|
|
|
|
dfilter_fail("You cannot test whether a function is present.");
|
|
|
|
THROW(TypeError);
|
|
|
|
break;
|
|
|
|
|
2004-02-11 21:20:52 +00:00
|
|
|
case STTYPE_UNINITIALIZED:
|
|
|
|
case STTYPE_TEST:
|
|
|
|
case STTYPE_INTEGER:
|
|
|
|
case STTYPE_FVALUE:
|
|
|
|
case STTYPE_NUM_TYPES:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-06-03 07:33:46 +00:00
|
|
|
struct check_drange_sanity_args {
|
|
|
|
stnode_t *st;
|
|
|
|
gboolean err;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Q: Where are sttype_range_drange() and sttype_range_hfinfo() defined?
|
|
|
|
*
|
|
|
|
* A: Those functions are defined by macros in epan/dfilter/sttype-range.h
|
|
|
|
*
|
|
|
|
* The macro which creates them, STTYPE_ACCESSOR, is defined in
|
|
|
|
* epan/dfilter/syntax-tree.h.
|
|
|
|
*
|
|
|
|
* From http://www.ethereal.com/lists/ethereal-dev/200308/msg00070.html
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_drange_node_sanity(gpointer data, gpointer user_data)
|
|
|
|
{
|
|
|
|
drange_node* drnode = data;
|
|
|
|
struct check_drange_sanity_args *args = user_data;
|
|
|
|
gint start_offset, end_offset, length;
|
|
|
|
header_field_info *hfinfo;
|
|
|
|
|
|
|
|
switch (drange_node_get_ending(drnode)) {
|
|
|
|
|
|
|
|
case LENGTH:
|
|
|
|
length = drange_node_get_length(drnode);
|
|
|
|
if (length <= 0) {
|
|
|
|
if (!args->err) {
|
|
|
|
args->err = TRUE;
|
|
|
|
start_offset = drange_node_get_start_offset(drnode);
|
|
|
|
hfinfo = sttype_range_hfinfo(args->st);
|
|
|
|
dfilter_fail("Range %d:%d specified for \"%s\" isn't valid, "
|
|
|
|
"as length %d isn't positive",
|
|
|
|
start_offset, length,
|
|
|
|
hfinfo->abbrev,
|
|
|
|
length);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OFFSET:
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
hfinfo = sttype_range_hfinfo(args->st);
|
|
|
|
dfilter_fail("Range %d-%d specified for \"%s\" isn't valid, "
|
|
|
|
"as %d is greater than %d",
|
|
|
|
start_offset, end_offset,
|
|
|
|
hfinfo->abbrev,
|
|
|
|
start_offset, end_offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TO_THE_END:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UNINITIALIZED:
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_drange_sanity(stnode_t *st)
|
|
|
|
{
|
|
|
|
struct check_drange_sanity_args args;
|
|
|
|
|
|
|
|
args.st = st;
|
|
|
|
args.err = FALSE;
|
|
|
|
|
|
|
|
drange_foreach_drange_node(sttype_range_drange(st),
|
|
|
|
check_drange_node_sanity, &args);
|
|
|
|
|
|
|
|
if (args.err) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
static void
|
|
|
|
check_function(stnode_t *st_node)
|
|
|
|
{
|
|
|
|
df_func_def_t *funcdef;
|
|
|
|
GSList *params;
|
|
|
|
guint iparam;
|
|
|
|
guint nparams;
|
|
|
|
|
|
|
|
funcdef = sttype_function_funcdef(st_node);
|
|
|
|
params = sttype_function_params(st_node);
|
|
|
|
nparams = g_slist_length(params);
|
|
|
|
|
|
|
|
if (nparams < funcdef->min_nargs) {
|
|
|
|
dfilter_fail("Function %s needs at least %u arguments.",
|
|
|
|
funcdef->name, funcdef->min_nargs);
|
|
|
|
THROW(TypeError);
|
|
|
|
} else if (nparams > funcdef->max_nargs) {
|
|
|
|
dfilter_fail("Function %s can only accept %u arguments.",
|
|
|
|
funcdef->name, funcdef->max_nargs);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
iparam = 0;
|
|
|
|
while (params) {
|
|
|
|
params->data = check_param_entity(params->data);
|
|
|
|
funcdef->semcheck_param_function(iparam, params->data);
|
|
|
|
params = params->next;
|
|
|
|
iparam++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
2003-07-25 03:44:05 +00:00
|
|
|
check_relation_LHS_FIELD(const char *relation_string, FtypeCanFunc can_func,
|
2003-08-27 15:23:11 +00:00
|
|
|
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;
|
|
|
|
sttype_id_t type1, type2;
|
|
|
|
header_field_info *hfinfo1, *hfinfo2;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
2001-02-01 20:21:25 +00:00
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
2001-02-27 19:23:30 +00:00
|
|
|
drange_node *rn;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
type1 = stnode_type_id(st_arg1);
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
hfinfo1 = stnode_data(st_arg1);
|
|
|
|
ftype1 = hfinfo1->type;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_FIELD(%s)\n", relation_string));
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!can_func(ftype1)) {
|
2003-07-25 03:44:05 +00:00
|
|
|
dfilter_fail("%s (type=%s) cannot participate in '%s' comparison.",
|
|
|
|
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) {
|
|
|
|
hfinfo2 = stnode_data(st_arg2);
|
|
|
|
ftype2 = hfinfo2->type;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
|
|
|
dfilter_fail("%s and %s are not of compatible types.",
|
|
|
|
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)) {
|
|
|
|
dfilter_fail("%s (type=%s) cannot participate in specified comparison.",
|
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else if (type2 == STTYPE_STRING) {
|
|
|
|
s = stnode_data(st_arg2);
|
2003-12-09 23:02:40 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
|
|
|
fvalue = fvalue_from_string(FT_PCRE, s, dfilter_fail);
|
|
|
|
} else {
|
|
|
|
fvalue = fvalue_from_string(ftype1, s, dfilter_fail);
|
2001-02-01 20:21:25 +00:00
|
|
|
if (!fvalue) {
|
2003-12-09 23:02:40 +00:00
|
|
|
/* check value_string */
|
|
|
|
fvalue = mk_fvalue_from_val_string(hfinfo1, s);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
2003-12-09 23:02:40 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED) {
|
|
|
|
s = stnode_data(st_arg2);
|
2003-12-09 23:02:40 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
|
|
|
fvalue = fvalue_from_unparsed(FT_PCRE, s, FALSE, dfilter_fail);
|
|
|
|
} else {
|
|
|
|
fvalue = fvalue_from_unparsed(ftype1, s, allow_partial_value, dfilter_fail);
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
2003-12-09 23:02:40 +00:00
|
|
|
/* check value_string */
|
|
|
|
fvalue = mk_fvalue_from_val_string(hfinfo1, s);
|
2003-07-25 03:44:05 +00:00
|
|
|
}
|
|
|
|
}
|
2003-12-09 23:02:40 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2004-06-03 07:33:46 +00:00
|
|
|
check_drange_sanity(st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!is_bytes_type(ftype1)) {
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
|
|
|
dfilter_fail("\"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
|
|
|
hfinfo1->abbrev,
|
|
|
|
ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert entire field to bytes */
|
|
|
|
new_st = stnode_new(STTYPE_RANGE, NULL);
|
|
|
|
|
|
|
|
rn = drange_node_new();
|
2001-03-02 17:04:25 +00:00
|
|
|
drange_node_set_start_offset(rn, 0);
|
|
|
|
drange_node_set_to_the_end(rn);
|
2001-02-27 19:23:30 +00:00
|
|
|
/* st_arg1 is freed in this step */
|
|
|
|
sttype_range_set1(new_st, st_arg1, rn);
|
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
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
|
|
|
funcdef = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
|
|
|
dfilter_fail("%s (type=%s) and return value of %s() (type=%s) are not of compatible types.",
|
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1),
|
|
|
|
funcdef->name, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
|
|
|
dfilter_fail("return value of %s() (type=%s) cannot participate in specified comparison.",
|
|
|
|
funcdef->name, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
check_function(st_arg2);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-02-22 03:04:41 +00:00
|
|
|
check_relation_LHS_STRING(const char* relation_string,
|
2009-06-01 18:24:42 +00:00
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value _U_,
|
2003-08-27 15:23:11 +00:00
|
|
|
stnode_t *st_node,
|
2001-02-27 19:23:30 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
|
|
|
sttype_id_t type1, type2;
|
|
|
|
header_field_info *hfinfo2;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
2001-02-27 19:23:30 +00:00
|
|
|
ftenum_t ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
type1 = stnode_type_id(st_arg1);
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_STRING()\n"));
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
|
|
|
hfinfo2 = stnode_data(st_arg2);
|
|
|
|
ftype2 = hfinfo2->type;
|
|
|
|
|
2004-02-22 03:04:41 +00:00
|
|
|
if (!can_func(ftype2)) {
|
|
|
|
dfilter_fail("%s (type=%s) cannot participate in '%s' comparison.",
|
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2),
|
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
s = stnode_data(st_arg1);
|
|
|
|
fvalue = fvalue_from_string(ftype2, s, dfilter_fail);
|
|
|
|
if (!fvalue) {
|
|
|
|
/* check value_string */
|
|
|
|
fvalue = mk_fvalue_from_val_string(hfinfo2, s);
|
2001-02-01 20:21:25 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2003-08-27 15:23:11 +00:00
|
|
|
else if (type2 == STTYPE_STRING || type2 == STTYPE_UNPARSED) {
|
2001-02-27 19:23:30 +00:00
|
|
|
/* Well now that's silly... */
|
|
|
|
dfilter_fail("Neither \"%s\" nor \"%s\" are field or protocol names.",
|
|
|
|
stnode_data(st_arg1),
|
|
|
|
stnode_data(st_arg2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2004-06-03 07:33:46 +00:00
|
|
|
check_drange_sanity(st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
s = stnode_data(st_arg1);
|
|
|
|
fvalue = fvalue_from_string(FT_BYTES, s, dfilter_fail);
|
|
|
|
if (!fvalue) {
|
2001-02-01 20:21:25 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
|
|
|
funcdef = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
|
|
|
dfilter_fail("Return value of function %s (type=%s) cannot participate in '%s' comparison.",
|
|
|
|
funcdef->name, ftype_pretty_name(ftype2),
|
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
s = stnode_data(st_arg1);
|
|
|
|
fvalue = fvalue_from_string(ftype2, s, dfilter_fail);
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
check_function(st_arg2);
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
static void
|
2004-02-22 03:04:41 +00:00
|
|
|
check_relation_LHS_UNPARSED(const char* relation_string,
|
|
|
|
FtypeCanFunc can_func, gboolean allow_partial_value,
|
2003-08-27 15:23:11 +00:00
|
|
|
stnode_t *st_node,
|
2003-07-25 03:44:05 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
|
|
|
sttype_id_t type1, type2;
|
|
|
|
header_field_info *hfinfo2;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
2003-07-25 03:44:05 +00:00
|
|
|
ftenum_t ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
type1 = stnode_type_id(st_arg1);
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_UNPARSED()\n"));
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
|
|
|
hfinfo2 = stnode_data(st_arg2);
|
|
|
|
ftype2 = hfinfo2->type;
|
|
|
|
|
2004-02-22 03:04:41 +00:00
|
|
|
if (!can_func(ftype2)) {
|
|
|
|
dfilter_fail("%s (type=%s) cannot participate in '%s' comparison.",
|
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2),
|
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
s = stnode_data(st_arg1);
|
2003-08-27 15:23:11 +00:00
|
|
|
fvalue = fvalue_from_unparsed(ftype2, s, allow_partial_value, dfilter_fail);
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
/* check value_string */
|
|
|
|
fvalue = mk_fvalue_from_val_string(hfinfo2, s);
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2003-08-27 15:23:11 +00:00
|
|
|
else if (type2 == STTYPE_STRING || type2 == STTYPE_UNPARSED) {
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Well now that's silly... */
|
|
|
|
dfilter_fail("Neither \"%s\" nor \"%s\" are field or protocol names.",
|
|
|
|
stnode_data(st_arg1),
|
|
|
|
stnode_data(st_arg2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2004-06-03 07:33:46 +00:00
|
|
|
check_drange_sanity(st_arg2);
|
2003-07-25 03:44:05 +00:00
|
|
|
s = stnode_data(st_arg1);
|
2003-08-27 15:23:11 +00:00
|
|
|
fvalue = fvalue_from_unparsed(FT_BYTES, s, allow_partial_value, dfilter_fail);
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
|
|
|
funcdef = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!can_func(ftype2)) {
|
|
|
|
dfilter_fail("return value of function %s() (type=%s) cannot participate in '%s' comparison.",
|
|
|
|
funcdef->name, ftype_pretty_name(ftype2), relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
s = stnode_data(st_arg1);
|
|
|
|
fvalue = fvalue_from_unparsed(ftype2, s, allow_partial_value, dfilter_fail);
|
|
|
|
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
check_function(st_arg2);
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, new_st, st_arg2);
|
|
|
|
stnode_free(st_arg1);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
static void
|
2004-01-01 16:59:20 +00:00
|
|
|
check_relation_LHS_RANGE(const char *relation_string, FtypeCanFunc can_func _U_,
|
|
|
|
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;
|
|
|
|
sttype_id_t type1, type2;
|
|
|
|
header_field_info *hfinfo1, *hfinfo2;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
2001-02-27 19:23:30 +00:00
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
drange_node *rn;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
type1 = stnode_type_id(st_arg1);
|
|
|
|
type2 = stnode_type_id(st_arg2);
|
|
|
|
hfinfo1 = sttype_range_hfinfo(st_arg1);
|
|
|
|
ftype1 = hfinfo1->type;
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(%s)\n", relation_string));
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!ftype_can_slice(ftype1)) {
|
|
|
|
dfilter_fail("\"%s\" is a %s and cannot be sliced into a sequence of bytes.",
|
|
|
|
hfinfo1->abbrev, ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-13 07:27:46 +00:00
|
|
|
check_drange_sanity(st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
if (type2 == STTYPE_FIELD) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_FIELD)\n"));
|
2004-05-09 08:17:32 +00:00
|
|
|
hfinfo2 = 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)) {
|
|
|
|
dfilter_fail("\"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
|
|
|
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 */
|
|
|
|
new_st = stnode_new(STTYPE_RANGE, NULL);
|
|
|
|
|
|
|
|
rn = drange_node_new();
|
2001-03-02 17:04:25 +00:00
|
|
|
drange_node_set_start_offset(rn, 0);
|
|
|
|
drange_node_set_to_the_end(rn);
|
2001-02-27 19:23:30 +00:00
|
|
|
/* st_arg2 is freed in this step */
|
|
|
|
sttype_range_set1(new_st, st_arg2, rn);
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_STRING) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_STRING)\n"));
|
2001-02-27 19:23:30 +00:00
|
|
|
s = stnode_data(st_arg2);
|
2004-01-01 16:59:20 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
|
|
|
fvalue = fvalue_from_string(FT_PCRE, s, dfilter_fail);
|
|
|
|
} else {
|
|
|
|
fvalue = fvalue_from_string(FT_BYTES, s, dfilter_fail);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
if (!fvalue) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_STRING): Could not convert from string!\n"));
|
2001-02-27 19:23:30 +00:00
|
|
|
THROW(TypeError);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
else if (type2 == STTYPE_UNPARSED) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_UNPARSED)\n"));
|
2003-07-25 03:44:05 +00:00
|
|
|
s = stnode_data(st_arg2);
|
2004-01-01 16:59:20 +00:00
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
|
|
|
fvalue = fvalue_from_unparsed(FT_PCRE, s, FALSE, dfilter_fail);
|
|
|
|
} else {
|
|
|
|
fvalue = fvalue_from_unparsed(FT_BYTES, s, allow_partial_value, dfilter_fail);
|
|
|
|
}
|
2003-07-25 03:44:05 +00:00
|
|
|
if (!fvalue) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_UNPARSED): Could not convert from string!\n"));
|
2003-07-25 03:44:05 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
2001-02-27 19:23:30 +00:00
|
|
|
else if (type2 == STTYPE_RANGE) {
|
2004-01-01 16:59:20 +00:00
|
|
|
DebugLog((" 5 check_relation_LHS_RANGE(type2 = STTYPE_RANGE)\n"));
|
2003-06-13 07:27:46 +00:00
|
|
|
check_drange_sanity(st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2009-05-31 19:46:31 +00:00
|
|
|
else if (type2 == STTYPE_FUNCTION) {
|
|
|
|
funcdef = sttype_function_funcdef(st_arg2);
|
|
|
|
ftype2 = funcdef->retval_ftype;
|
|
|
|
|
|
|
|
if (!is_bytes_type(ftype2)) {
|
|
|
|
if (!ftype_can_slice(ftype2)) {
|
|
|
|
dfilter_fail("Return value of function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
|
|
|
funcdef->name,
|
|
|
|
ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX should I add a new drange node? */
|
|
|
|
}
|
|
|
|
|
|
|
|
check_function(st_arg2);
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-02 14:26:17 +00:00
|
|
|
static stnode_t*
|
|
|
|
check_param_entity(stnode_t *st_node)
|
|
|
|
{
|
|
|
|
sttype_id_t e_type;
|
|
|
|
stnode_t *new_st;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
e_type = stnode_type_id(st_node);
|
|
|
|
/* If there's an unparsed string, change it to an FT_STRING */
|
|
|
|
if (e_type == STTYPE_UNPARSED) {
|
|
|
|
s = stnode_data(st_node);
|
|
|
|
fvalue = fvalue_from_unparsed(FT_STRING, s, FALSE, dfilter_fail);
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
stnode_free(st_node);
|
|
|
|
return new_st;
|
|
|
|
}
|
|
|
|
|
|
|
|
return st_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* If the LHS of a relation test is a FUNCTION, run some checks
|
|
|
|
* and possibly some modifications of syntax tree nodes. */
|
|
|
|
static void
|
|
|
|
check_relation_LHS_FUNCTION(const char *relation_string, FtypeCanFunc can_func,
|
|
|
|
gboolean allow_partial_value,
|
|
|
|
stnode_t *st_node, stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
|
|
|
stnode_t *new_st;
|
|
|
|
sttype_id_t type2;
|
|
|
|
header_field_info *hfinfo2;
|
|
|
|
ftenum_t ftype1, ftype2;
|
|
|
|
fvalue_t *fvalue;
|
|
|
|
char *s;
|
|
|
|
drange_node *rn;
|
2009-05-31 19:46:31 +00:00
|
|
|
df_func_def_t *funcdef;
|
|
|
|
df_func_def_t *funcdef2;
|
|
|
|
GSList *params;
|
2006-05-02 14:26:17 +00:00
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
check_function(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;
|
|
|
|
|
2009-05-31 19:46:31 +00:00
|
|
|
params = sttype_function_params(st_arg1);
|
2006-05-02 14:26:17 +00:00
|
|
|
|
|
|
|
DebugLog((" 5 check_relation_LHS_FUNCTION(%s)\n", relation_string));
|
|
|
|
|
|
|
|
if (!can_func(ftype1)) {
|
|
|
|
dfilter_fail("Function %s (type=%s) cannot participate in '%s' comparison.",
|
|
|
|
funcdef->name, ftype_pretty_name(ftype1),
|
|
|
|
relation_string);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type2 == STTYPE_FIELD) {
|
|
|
|
hfinfo2 = stnode_data(st_arg2);
|
|
|
|
ftype2 = hfinfo2->type;
|
|
|
|
|
|
|
|
if (!compatible_ftypes(ftype1, ftype2)) {
|
|
|
|
dfilter_fail("Function %s and %s are not of compatible types.",
|
|
|
|
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)) {
|
|
|
|
dfilter_fail("%s (type=%s) cannot participate in specified comparison.",
|
|
|
|
hfinfo2->abbrev, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_STRING) {
|
|
|
|
s = stnode_data(st_arg2);
|
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
|
|
|
fvalue = fvalue_from_string(FT_PCRE, s, dfilter_fail);
|
|
|
|
} else {
|
|
|
|
fvalue = fvalue_from_string(ftype1, s, dfilter_fail);
|
|
|
|
}
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_UNPARSED) {
|
|
|
|
s = stnode_data(st_arg2);
|
|
|
|
if (strcmp(relation_string, "matches") == 0) {
|
|
|
|
/* Convert to a FT_PCRE */
|
|
|
|
fvalue = fvalue_from_unparsed(FT_PCRE, s, FALSE, dfilter_fail);
|
|
|
|
} else {
|
|
|
|
fvalue = fvalue_from_unparsed(ftype1, s, allow_partial_value, dfilter_fail);
|
|
|
|
}
|
|
|
|
if (!fvalue) {
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_st = stnode_new(STTYPE_FVALUE, fvalue);
|
|
|
|
sttype_test_set2_args(st_node, st_arg1, new_st);
|
|
|
|
stnode_free(st_arg2);
|
|
|
|
}
|
|
|
|
else if (type2 == STTYPE_RANGE) {
|
|
|
|
check_drange_sanity(st_arg2);
|
|
|
|
if (!is_bytes_type(ftype1)) {
|
|
|
|
if (!ftype_can_slice(ftype1)) {
|
|
|
|
dfilter_fail("Function \"%s\" is a %s and cannot be converted into a sequence of bytes.",
|
|
|
|
funcdef->name,
|
|
|
|
ftype_pretty_name(ftype1));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert entire field to bytes */
|
|
|
|
new_st = stnode_new(STTYPE_RANGE, NULL);
|
|
|
|
|
|
|
|
rn = drange_node_new();
|
|
|
|
drange_node_set_start_offset(rn, 0);
|
|
|
|
drange_node_set_to_the_end(rn);
|
|
|
|
/* st_arg1 is freed in this step */
|
|
|
|
sttype_range_set1(new_st, st_arg1, rn);
|
|
|
|
|
|
|
|
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)) {
|
|
|
|
dfilter_fail("Return values of function %s (type=%s) and function %s (type=%s) are not of compatible types.",
|
|
|
|
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)) {
|
|
|
|
dfilter_fail("Return value of %s (type=%s) cannot participate in specified comparison.",
|
|
|
|
funcdef2->name, ftype_pretty_name(ftype2));
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
check_function(st_arg2);
|
|
|
|
}
|
2006-05-02 14:26:17 +00:00
|
|
|
else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the semantics of any relational test. */
|
2001-02-27 19:23:30 +00:00
|
|
|
static void
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation(const char *relation_string, gboolean allow_partial_value,
|
|
|
|
FtypeCanFunc can_func, stnode_t *st_node,
|
2001-02-27 19:23:30 +00:00
|
|
|
stnode_t *st_arg1, stnode_t *st_arg2)
|
|
|
|
{
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
2004-05-09 08:17:32 +00:00
|
|
|
header_field_info *hfinfo;
|
2003-12-09 23:02:40 +00:00
|
|
|
|
|
|
|
DebugLog((" 4 check_relation(\"%s\") [%u]\n", relation_string, i++));
|
2004-05-09 08:17:32 +00:00
|
|
|
|
|
|
|
/* Protocol can only be on LHS (for "contains" or "matches" operators).
|
|
|
|
* Check to see if protocol is on RHS. This catches the case where the
|
|
|
|
* user has written "fc" on the RHS, probably intending a byte value
|
|
|
|
* rather than the fibre channel protocol.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (stnode_type_id(st_arg2) == STTYPE_FIELD) {
|
|
|
|
hfinfo = stnode_data(st_arg2);
|
|
|
|
if (hfinfo->type == FT_PROTOCOL)
|
|
|
|
dfilter_fail("Protocol (\"%s\") cannot appear on right-hand side of comparison.", hfinfo->abbrev);
|
|
|
|
THROW(TypeError);
|
|
|
|
}
|
|
|
|
|
2001-02-27 19:23:30 +00:00
|
|
|
switch (stnode_type_id(st_arg1)) {
|
|
|
|
case STTYPE_FIELD:
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation_LHS_FIELD(relation_string, can_func,
|
|
|
|
allow_partial_value, st_node, st_arg1, st_arg2);
|
2001-02-27 19:23:30 +00:00
|
|
|
break;
|
|
|
|
case STTYPE_STRING:
|
2004-02-22 03:04:41 +00:00
|
|
|
check_relation_LHS_STRING(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:
|
2004-01-01 16:59:20 +00:00
|
|
|
check_relation_LHS_RANGE(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:
|
2004-02-22 03:04:41 +00:00
|
|
|
check_relation_LHS_UNPARSED(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:
|
|
|
|
check_relation_LHS_FUNCTION(relation_string, can_func,
|
|
|
|
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:
|
2006-05-02 14:26:17 +00:00
|
|
|
default:
|
2001-02-27 19:23:30 +00:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the semantics of any type of TEST */
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2002-02-27 18:54:33 +00:00
|
|
|
check_test(stnode_t *st_node)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
|
|
|
test_op_t st_op;
|
|
|
|
stnode_t *st_arg1, *st_arg2;
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
DebugLog((" 3 check_test(stnode_t *st_node = %p) [%u]\n", st_node, i));
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
sttype_test_get(st_node, &st_op, &st_arg1, &st_arg2);
|
|
|
|
|
|
|
|
switch (st_op) {
|
|
|
|
case TEST_OP_UNINITIALIZED:
|
|
|
|
g_assert_not_reached();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_EXISTS:
|
2004-02-11 21:20:52 +00:00
|
|
|
check_exists(st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_NOT:
|
2002-03-02 20:51:46 +00:00
|
|
|
semcheck(st_arg1);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_AND:
|
|
|
|
case TEST_OP_OR:
|
2002-02-27 18:54:33 +00:00
|
|
|
semcheck(st_arg1);
|
|
|
|
semcheck(st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TEST_OP_EQ:
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation("==", FALSE, ftype_can_eq, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_NE:
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation("!=", FALSE, ftype_can_ne, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_GT:
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation(">", FALSE, ftype_can_gt, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_GE:
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation(">=", FALSE, ftype_can_ge, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_LT:
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation("<", FALSE, ftype_can_lt, st_node, st_arg1, st_arg2);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
case TEST_OP_LE:
|
2003-08-27 15:23:11 +00:00
|
|
|
check_relation("<=", FALSE, ftype_can_le, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2004-02-27 12:00:32 +00:00
|
|
|
case TEST_OP_BITWISE_AND:
|
|
|
|
check_relation("&", FALSE, ftype_can_bitwise_and, st_node, st_arg1, st_arg2);
|
|
|
|
break;
|
2003-08-27 15:23:11 +00:00
|
|
|
case TEST_OP_CONTAINS:
|
|
|
|
check_relation("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:
|
|
|
|
#ifdef HAVE_LIBPCRE
|
|
|
|
check_relation("matches", TRUE, ftype_can_matches, st_node, st_arg1, st_arg2);
|
|
|
|
#else
|
2006-05-28 19:49:07 +00:00
|
|
|
dfilter_fail("This Wireshark version does not support the \"matches\" operation.");
|
2003-12-06 16:35:20 +00:00
|
|
|
THROW(TypeError);
|
|
|
|
#endif
|
|
|
|
break;
|
2003-08-27 15:23:11 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
2003-12-09 23:02:40 +00:00
|
|
|
DebugLog((" 3 check_test(stnode_t *st_node = %p) [%u] - End\n", st_node, i++));
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the entire syntax tree. */
|
2001-02-01 20:21:25 +00:00
|
|
|
static void
|
2002-02-27 18:54:33 +00:00
|
|
|
semcheck(stnode_t *st_node)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
DebugLog((" 2 semcheck(stnode_t *st_node = %p) [%u]\n", st_node, i++));
|
2003-07-25 03:44:05 +00:00
|
|
|
/* The parser assures that the top-most syntax-tree
|
|
|
|
* node will be a TEST node, no matter what. So assert that. */
|
2001-02-01 20:21:25 +00:00
|
|
|
switch (stnode_type_id(st_node)) {
|
|
|
|
case STTYPE_TEST:
|
2002-02-27 18:54:33 +00:00
|
|
|
check_test(st_node);
|
2001-02-01 20:21:25 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Check the syntax tree for semantic errors, and convert
|
|
|
|
* some of the nodes into the form they need to be in order to
|
|
|
|
* later generate the DFVM bytecode. */
|
2001-02-01 20:21:25 +00:00
|
|
|
gboolean
|
|
|
|
dfw_semcheck(dfwork_t *dfw)
|
|
|
|
{
|
2007-04-17 15:13:17 +00:00
|
|
|
volatile gboolean ok_filter = TRUE;
|
2003-12-09 23:02:40 +00:00
|
|
|
#ifdef DEBUG_dfilter
|
|
|
|
static guint i = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
DebugLog(("1 dfw_semcheck(dfwork_t *dfw = %p) [%u]\n", dfw, i));
|
2003-07-25 03:44:05 +00:00
|
|
|
/* Instead of having to check for errors at every stage of
|
|
|
|
* the semantic-checking, the semantic-checking code will
|
|
|
|
* throw an exception if a problem is found. */
|
2001-02-01 20:21:25 +00:00
|
|
|
TRY {
|
2002-02-27 18:54:33 +00:00
|
|
|
semcheck(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;
|
|
|
|
|
2007-04-17 15:13:17 +00:00
|
|
|
DebugLog(("1 dfw_semcheck(dfwork_t *dfw = %p) [%u] - Returns %d\n",
|
|
|
|
dfw, i++,ok_filter));
|
|
|
|
return ok_filter;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|