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
|
|
|
|
|
2009-08-26 19:27:49 +00:00
|
|
|
#include <stdio.h>
|
2001-02-01 20:21:25 +00:00
|
|
|
#include <errno.h>
|
|
|
|
#include "ftypes-int.h"
|
2004-08-06 19:57:49 +00:00
|
|
|
#include <epan/addr_resolv.h>
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
int_fvalue_new(fvalue_t *fv)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
fv->value.uinteger = 0;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger(fvalue_t *fv, guint32 value)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
fv->value.uinteger = value;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2007-01-18 11:02:26 +00:00
|
|
|
static void
|
|
|
|
set_sinteger(fvalue_t *fv, gint32 value)
|
|
|
|
{
|
|
|
|
fv->value.sinteger = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
static guint32
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger(fvalue_t *fv)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return fv->value.uinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2007-01-18 11:02:26 +00:00
|
|
|
static gint32
|
|
|
|
get_sinteger(fvalue_t *fv)
|
|
|
|
{
|
|
|
|
return fv->value.sinteger;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
static gboolean
|
2010-04-30 21:40:39 +00:00
|
|
|
uint_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
2004-07-16 23:35:46 +00:00
|
|
|
unsigned long value;
|
2001-02-01 20:21:25 +00:00
|
|
|
char *endptr;
|
|
|
|
|
2004-07-16 23:35:46 +00:00
|
|
|
errno = 0;
|
|
|
|
value = strtoul(s, &endptr, 0);
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2004-07-16 23:35:46 +00:00
|
|
|
if (errno == EINVAL || endptr == s || *endptr != '\0') {
|
2001-02-01 20:21:25 +00:00
|
|
|
/* This isn't a valid number. */
|
2002-02-05 22:50:17 +00:00
|
|
|
if (logfunc != NULL)
|
|
|
|
logfunc("\"%s\" is not a valid number.", s);
|
2001-02-01 20:21:25 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (errno == ERANGE) {
|
2002-02-05 22:50:17 +00:00
|
|
|
if (logfunc != NULL) {
|
2004-07-16 23:35:46 +00:00
|
|
|
if (value == ULONG_MAX) {
|
2002-02-05 22:50:17 +00:00
|
|
|
logfunc("\"%s\" causes an integer overflow.",
|
|
|
|
s);
|
2001-03-03 00:33:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2004-07-16 23:35:46 +00:00
|
|
|
/*
|
|
|
|
* XXX - can "strtoul()" set errno to
|
|
|
|
* ERANGE without returning ULONG_MAX?
|
|
|
|
*/
|
2002-02-05 22:50:17 +00:00
|
|
|
logfunc("\"%s\" is not an integer.", s);
|
2001-03-03 00:33:24 +00:00
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
2004-07-16 23:35:46 +00:00
|
|
|
if (value > G_MAXUINT32) {
|
|
|
|
/*
|
|
|
|
* Fits in an unsigned long, but not in a guint32
|
|
|
|
* (an unsigned long might be 64 bits).
|
|
|
|
*/
|
|
|
|
if (logfunc != NULL)
|
|
|
|
logfunc("\"%s\" causes an integer overflow.", s);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2009-04-22 03:07:37 +00:00
|
|
|
fv->value.uinteger = (guint32)value;
|
2001-02-01 20:21:25 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2010-04-30 21:40:39 +00:00
|
|
|
static gboolean
|
|
|
|
sint_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
|
|
|
|
{
|
|
|
|
long value;
|
|
|
|
char *endptr;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
value = strtol(s, &endptr, 0);
|
|
|
|
|
|
|
|
if (errno == EINVAL || endptr == s || *endptr != '\0') {
|
|
|
|
/* This isn't a valid number. */
|
|
|
|
if (logfunc != NULL)
|
|
|
|
logfunc("\"%s\" is not a valid number.", s);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (errno == ERANGE) {
|
|
|
|
if (logfunc != NULL) {
|
|
|
|
if (value == LONG_MAX) {
|
|
|
|
logfunc("\"%s\" causes an integer overflow.",
|
|
|
|
s);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/*
|
2010-04-30 21:51:47 +00:00
|
|
|
* XXX - can "strtol()" set errno to
|
2010-04-30 21:40:39 +00:00
|
|
|
* ERANGE without returning ULONG_MAX?
|
|
|
|
*/
|
|
|
|
logfunc("\"%s\" is not an integer.", s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (value > G_MAXINT32) {
|
|
|
|
/*
|
|
|
|
* Fits in an long, but not in a gint32
|
|
|
|
* (a long might be 64 bits).
|
|
|
|
*/
|
|
|
|
if (logfunc != NULL)
|
|
|
|
logfunc("\"%s\" causes an integer overflow.", s);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2010-04-30 21:55:42 +00:00
|
|
|
if (value < G_MININT32) {
|
|
|
|
/*
|
|
|
|
* Fits in a long, but not in a gint32 (a long might be
|
|
|
|
* 64 bits).
|
|
|
|
*/
|
|
|
|
if (logfunc != NULL)
|
|
|
|
logfunc("\"%s\" causes an integer underflow.", s);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2010-04-30 21:40:39 +00:00
|
|
|
|
|
|
|
fv->value.sinteger = (gint32)value;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2005-10-31 02:42:22 +00:00
|
|
|
static int
|
|
|
|
integer_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
|
|
|
|
{
|
|
|
|
return 11; /* enough for 12^31-1, in decimal */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
integer_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
|
|
|
|
{
|
2010-02-23 19:28:38 +00:00
|
|
|
guint32 val;
|
|
|
|
|
|
|
|
if (fv->value.sinteger < 0) {
|
|
|
|
*buf++ = '-';
|
|
|
|
val = -fv->value.sinteger;
|
|
|
|
} else
|
|
|
|
val = fv->value.sinteger;
|
|
|
|
|
|
|
|
guint32_to_str_buf(val, buf, 11);
|
2005-10-31 02:42:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
uinteger_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
|
|
|
|
{
|
|
|
|
return 10; /* enough for 2^32-1, in decimal */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
uinteger_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
|
|
|
|
{
|
2010-02-23 19:28:38 +00:00
|
|
|
guint32_to_str_buf(fv->value.uinteger, buf, 11);
|
2005-10-31 02:42:22 +00:00
|
|
|
}
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
static gboolean
|
2003-08-27 15:23:11 +00:00
|
|
|
ipxnet_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
|
2001-02-01 20:21:25 +00:00
|
|
|
{
|
|
|
|
guint32 val;
|
|
|
|
gboolean known;
|
|
|
|
|
2001-03-03 00:33:24 +00:00
|
|
|
/*
|
|
|
|
* Don't log a message if this fails; we'll try looking it
|
|
|
|
* up as an IPX network name if it does, and if that fails,
|
|
|
|
* we'll log a message.
|
|
|
|
*/
|
2010-04-30 21:40:39 +00:00
|
|
|
if (uint_from_unparsed(fv, s, TRUE, NULL)) {
|
2001-02-01 20:21:25 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = get_ipxnet_addr(s, &known);
|
|
|
|
if (known) {
|
2007-01-18 11:02:26 +00:00
|
|
|
fv->value.uinteger = val;
|
2001-02-01 20:21:25 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2002-02-05 22:50:17 +00:00
|
|
|
logfunc("\"%s\" is not a valid IPX network name or address.", s);
|
2001-02-01 20:21:25 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2005-10-31 02:42:22 +00:00
|
|
|
static int
|
|
|
|
ipxnet_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
|
|
|
|
{
|
|
|
|
return 2+8; /* 0xXXXXXXXX */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ipxnet_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
sprintf(buf, "0x%08x", fv->value.uinteger);
|
2005-10-31 02:42:22 +00:00
|
|
|
}
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
static gboolean
|
|
|
|
cmp_eq(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.uinteger == b->value.uinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
cmp_ne(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.uinteger != b->value.uinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_gt(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.uinteger > b->value.uinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_ge(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.uinteger >= b->value.uinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_lt(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.uinteger < b->value.uinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_le(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.uinteger <= b->value.uinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_gt(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.sinteger > b->value.sinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_ge(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.sinteger >= b->value.sinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_lt(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.sinteger < b->value.sinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_le(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return a->value.sinteger <= b->value.sinteger;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2004-02-27 12:00:32 +00:00
|
|
|
static gboolean
|
|
|
|
cmp_bitwise_and(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
return ((a->value.uinteger & b->value.uinteger) != 0);
|
2004-02-27 12:00:32 +00:00
|
|
|
}
|
|
|
|
|
2004-08-22 00:31:58 +00:00
|
|
|
static void
|
|
|
|
int64_fvalue_new(fvalue_t *fv)
|
|
|
|
{
|
|
|
|
fv->value.integer64 = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_integer64(fvalue_t *fv, guint64 value)
|
|
|
|
{
|
|
|
|
fv->value.integer64 = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
static guint64
|
|
|
|
get_integer64(fvalue_t *fv)
|
|
|
|
{
|
|
|
|
return fv->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
val64_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
|
|
|
|
{
|
|
|
|
guint64 value;
|
|
|
|
char *endptr;
|
|
|
|
|
|
|
|
errno = 0;
|
2004-09-03 18:14:00 +00:00
|
|
|
value = g_ascii_strtoull(s, &endptr, 0);
|
2004-08-22 00:31:58 +00:00
|
|
|
|
|
|
|
if (errno == EINVAL || endptr == s || *endptr != '\0') {
|
|
|
|
/* This isn't a valid number. */
|
|
|
|
if (logfunc != NULL)
|
|
|
|
logfunc("\"%s\" is not a valid number.", s);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (errno == ERANGE) {
|
|
|
|
if (logfunc != NULL) {
|
|
|
|
if (value == ULONG_MAX) {
|
|
|
|
logfunc("\"%s\" causes an integer overflow.",
|
|
|
|
s);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* XXX - can "strtoul()" set errno to
|
|
|
|
* ERANGE without returning ULONG_MAX?
|
|
|
|
*/
|
|
|
|
logfunc("\"%s\" is not an integer.", s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (value > G_MAXUINT64) {
|
|
|
|
/*
|
|
|
|
* Fits in an unsigned long, but not in a guint64
|
|
|
|
* (unlikely, but not impossible).
|
|
|
|
*/
|
|
|
|
if (logfunc != NULL)
|
|
|
|
logfunc("\"%s\" causes an integer overflow.", s);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
fv->value.integer64 = value;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2005-10-31 02:42:22 +00:00
|
|
|
static int
|
|
|
|
integer64_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
|
|
|
|
{
|
|
|
|
return 20; /* enough for -2^63-1, in decimal */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
integer64_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
|
|
|
|
{
|
2007-12-05 09:05:52 +00:00
|
|
|
sprintf(buf, "%" G_GINT64_MODIFIER "d", fv->value.integer64);
|
2005-10-31 02:42:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
uinteger64_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
|
|
|
|
{
|
|
|
|
return 20; /* enough for 2^64-1, in decimal */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
uinteger64_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
|
|
|
|
{
|
2007-12-05 09:05:52 +00:00
|
|
|
sprintf(buf, "%" G_GINT64_MODIFIER "u", fv->value.integer64);
|
2005-10-31 02:42:22 +00:00
|
|
|
}
|
|
|
|
|
2004-08-22 00:31:58 +00:00
|
|
|
static gboolean
|
|
|
|
cmp_eq64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return a->value.integer64 == b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
cmp_ne64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return a->value.integer64 != b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_gt64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return (gint64)a->value.integer64 > (gint64)b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_ge64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return (gint64)a->value.integer64 >= (gint64)b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_lt64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return (gint64)a->value.integer64 < (gint64)b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
u_cmp_le64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return (gint64)a->value.integer64 <= (gint64)b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_gt64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return a->value.integer64 > b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_ge64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return a->value.integer64 >= b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_lt64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return a->value.integer64 < b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
s_cmp_le64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return a->value.integer64 <= b->value.integer64;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
cmp_bitwise_and64(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2004-08-25 03:44:04 +00:00
|
|
|
return ((a->value.integer64 & b->value.integer64) != 0);
|
2004-08-22 00:31:58 +00:00
|
|
|
}
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
/* BOOLEAN-specific */
|
|
|
|
|
|
|
|
static void
|
|
|
|
boolean_fvalue_new(fvalue_t *fv)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
fv->value.uinteger = TRUE;
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
static int
|
|
|
|
boolean_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
boolean_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
|
|
|
|
{
|
2010-02-23 19:28:38 +00:00
|
|
|
*buf++ = (fv->value.uinteger) ? '1' : '0';
|
|
|
|
*buf = '\0';
|
2003-06-11 21:24:54 +00:00
|
|
|
}
|
|
|
|
|
2001-02-11 03:29:53 +00:00
|
|
|
/* Checks for equality with zero or non-zero */
|
|
|
|
static gboolean
|
|
|
|
bool_eq(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
2007-01-18 11:02:26 +00:00
|
|
|
if (a->value.uinteger) {
|
|
|
|
if (b->value.uinteger) {
|
2001-02-11 03:29:53 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2007-01-18 11:02:26 +00:00
|
|
|
if (b->value.uinteger) {
|
2001-02-11 03:29:53 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2001-02-11 03:29:53 +00:00
|
|
|
/* Checks for inequality with zero or non-zero */
|
|
|
|
static gboolean
|
|
|
|
bool_ne(fvalue_t *a, fvalue_t *b)
|
|
|
|
{
|
|
|
|
return (!bool_eq(a,b));
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2011-05-08 10:23:53 +00:00
|
|
|
/* EUI64-specific */
|
|
|
|
static gboolean
|
|
|
|
eui64_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't log a message if this fails; we'll try looking it
|
|
|
|
* up as an EUI64 Address if it does, and if that fails,
|
|
|
|
* we'll log a message.
|
|
|
|
*/
|
|
|
|
if (val64_from_unparsed(fv, s, TRUE, NULL)) {
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
logfunc("\"%s\" is not a valid EUI64 Address", s);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2011-05-08 10:23:53 +00:00
|
|
|
static int
|
|
|
|
eui64_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
|
|
|
|
{
|
|
|
|
return 8*3-1; /* XX:XX:XX:XX:XX:XX:XX:XX */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eui64_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
|
|
|
|
{
|
|
|
|
guint8 *p_eui64 = ep_alloc(8);
|
|
|
|
|
|
|
|
/* Copy and convert the address to network byte order. */
|
2011-05-16 21:42:49 +00:00
|
|
|
*(guint64 *)(void *)(p_eui64) = pntoh64(&(fv->value.integer64));
|
2011-05-08 10:23:53 +00:00
|
|
|
|
2011-06-14 20:37:53 +00:00
|
|
|
g_snprintf(buf, EUI64_STR_LEN, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
|
2011-05-08 10:23:53 +00:00
|
|
|
p_eui64[0], p_eui64[1], p_eui64[2], p_eui64[3],
|
|
|
|
p_eui64[4], p_eui64[5], p_eui64[6], p_eui64[7] );
|
|
|
|
}
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
ftype_register_integers(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
static ftype_t uint8_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_UINT8, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_UINT8", /* name */
|
|
|
|
"unsigned, 1 byte", /* pretty name */
|
|
|
|
1, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
uint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
uinteger_to_repr, /* val_to_string_repr */
|
|
|
|
uinteger_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger, /* get_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
u_cmp_gt,
|
|
|
|
u_cmp_ge,
|
|
|
|
u_cmp_lt,
|
|
|
|
u_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
static ftype_t uint16_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_UINT16, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_UINT16", /* name */
|
|
|
|
"unsigned, 2 bytes", /* pretty_name */
|
|
|
|
2, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
uint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
uinteger_to_repr, /* val_to_string_repr */
|
|
|
|
uinteger_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger, /* get_value_integer */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
u_cmp_gt,
|
|
|
|
u_cmp_ge,
|
|
|
|
u_cmp_lt,
|
|
|
|
u_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
static ftype_t uint24_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_UINT24, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_UINT24", /* name */
|
|
|
|
"unsigned, 3 bytes", /* pretty_name */
|
|
|
|
3, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
uint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
uinteger_to_repr, /* val_to_string_repr */
|
|
|
|
uinteger_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger, /* set_value_integer */
|
|
|
|
NULL, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger, /* get_value_integer */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
u_cmp_gt,
|
|
|
|
u_cmp_ge,
|
|
|
|
u_cmp_lt,
|
|
|
|
u_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
static ftype_t uint32_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_UINT32, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_UINT32", /* name */
|
|
|
|
"unsigned, 4 bytes", /* pretty_name */
|
|
|
|
4, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
uint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
uinteger_to_repr, /* val_to_string_repr */
|
|
|
|
uinteger_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger, /* get_value_integer */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
u_cmp_gt,
|
|
|
|
u_cmp_ge,
|
|
|
|
u_cmp_lt,
|
|
|
|
u_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
2004-08-22 00:31:58 +00:00
|
|
|
static ftype_t uint64_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_UINT64, /* ftype */
|
2004-08-22 00:31:58 +00:00
|
|
|
"FT_UINT64", /* name */
|
|
|
|
"unsigned, 8 bytes", /* pretty_name */
|
|
|
|
8, /* wire_size */
|
|
|
|
int64_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
|
|
|
val64_from_unparsed, /* val_from_unparsed */
|
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
uinteger64_to_repr, /* val_to_string_repr */
|
|
|
|
uinteger64_repr_len, /* len_string_repr */
|
2004-08-22 00:31:58 +00:00
|
|
|
|
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
|
|
|
set_integer64, /* set_value_integer64 */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_floating */
|
|
|
|
|
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* get_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
|
|
|
get_integer64, /* get_value_integer64 */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_floating */
|
|
|
|
|
|
|
|
cmp_eq64,
|
|
|
|
cmp_ne64,
|
|
|
|
u_cmp_gt64,
|
|
|
|
u_cmp_ge64,
|
|
|
|
u_cmp_lt64,
|
|
|
|
u_cmp_le64,
|
|
|
|
cmp_bitwise_and64,
|
|
|
|
NULL, /* cmp_contains */
|
|
|
|
NULL, /* cmp_matches */
|
|
|
|
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
};
|
2001-02-01 20:21:25 +00:00
|
|
|
static ftype_t int8_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_INT8, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_INT8", /* name */
|
|
|
|
"signed, 1 byte", /* pretty_name */
|
|
|
|
1, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
sint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
integer_to_repr, /* val_to_string_repr */
|
|
|
|
integer_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* set_value_uinteger */
|
|
|
|
set_sinteger, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* get_value_uinteger */
|
|
|
|
get_sinteger, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
s_cmp_gt,
|
|
|
|
s_cmp_ge,
|
|
|
|
s_cmp_lt,
|
|
|
|
s_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
static ftype_t int16_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_INT16, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_INT16", /* name */
|
|
|
|
"signed, 2 bytes", /* pretty_name */
|
|
|
|
2, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
sint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
integer_to_repr, /* val_to_string_repr */
|
|
|
|
integer_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* set_value_uinteger */
|
|
|
|
set_sinteger, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* get_value_uinteger */
|
|
|
|
get_sinteger, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
s_cmp_gt,
|
|
|
|
s_cmp_ge,
|
|
|
|
s_cmp_lt,
|
|
|
|
s_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
static ftype_t int24_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_INT24, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_INT24", /* name */
|
|
|
|
"signed, 3 bytes", /* pretty_name */
|
|
|
|
3, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
sint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
integer_to_repr, /* val_to_string_repr */
|
|
|
|
integer_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* set_value_uinteger */
|
|
|
|
set_sinteger, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* get_value_uinteger */
|
|
|
|
get_sinteger, /* get_value_integer */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
s_cmp_gt,
|
|
|
|
s_cmp_ge,
|
|
|
|
s_cmp_lt,
|
|
|
|
s_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
static ftype_t int32_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_INT32, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_INT32", /* name */
|
|
|
|
"signed, 4 bytes", /* pretty_name */
|
|
|
|
4, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
sint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
integer_to_repr, /* val_to_string_repr */
|
|
|
|
integer_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* set_value_uinteger */
|
|
|
|
set_sinteger, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* get_value_uinteger */
|
|
|
|
get_sinteger, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
s_cmp_gt,
|
|
|
|
s_cmp_ge,
|
|
|
|
s_cmp_lt,
|
|
|
|
s_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
2004-08-22 00:31:58 +00:00
|
|
|
static ftype_t int64_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_INT64, /* ftype */
|
2004-08-22 00:31:58 +00:00
|
|
|
"FT_INT64", /* name */
|
|
|
|
"signed, 8 bytes", /* pretty_name */
|
|
|
|
8, /* wire_size */
|
|
|
|
int64_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
|
|
|
val64_from_unparsed, /* val_from_unparsed */
|
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
integer64_to_repr, /* val_to_string_repr */
|
|
|
|
integer64_repr_len, /* len_string_repr */
|
2004-08-22 00:31:58 +00:00
|
|
|
|
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
|
|
|
set_integer64, /* set_value_integer64 */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_floating */
|
|
|
|
|
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
NULL, /* get_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
|
|
|
get_integer64, /* get_value_integer64 */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_floating */
|
|
|
|
|
|
|
|
cmp_eq64,
|
|
|
|
cmp_ne64,
|
|
|
|
s_cmp_gt64,
|
|
|
|
s_cmp_ge64,
|
|
|
|
s_cmp_lt64,
|
|
|
|
s_cmp_le64,
|
|
|
|
cmp_bitwise_and64,
|
|
|
|
NULL, /* cmp_contains */
|
|
|
|
NULL, /* cmp_matches */
|
|
|
|
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
};
|
2001-02-01 20:21:25 +00:00
|
|
|
static ftype_t boolean_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_BOOLEAN, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_BOOLEAN", /* name */
|
|
|
|
"Boolean", /* pretty_name */
|
|
|
|
0, /* wire_size */
|
|
|
|
boolean_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
uint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2003-06-11 21:24:54 +00:00
|
|
|
boolean_to_repr, /* val_to_string_repr */
|
|
|
|
boolean_repr_len, /* len_string_repr */
|
|
|
|
|
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
|
|
|
|
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger, /* get_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
|
|
|
|
|
|
|
bool_eq, /* cmp_eq */
|
|
|
|
bool_ne, /* cmp_ne */
|
|
|
|
NULL, /* cmp_gt */
|
|
|
|
NULL, /* cmp_ge */
|
|
|
|
NULL, /* cmp_lt */
|
|
|
|
NULL, /* cmp_le */
|
2004-02-27 12:00:32 +00:00
|
|
|
NULL, /* cmp_bitwise_and */
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2003-06-11 21:24:54 +00:00
|
|
|
|
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static ftype_t ipxnet_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_IPXNET, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_IPXNET", /* name */
|
|
|
|
"IPX network number", /* pretty_name */
|
|
|
|
4, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2003-07-25 03:44:05 +00:00
|
|
|
ipxnet_from_unparsed, /* val_from_unparsed */
|
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
ipxnet_to_repr, /* val_to_string_repr */
|
|
|
|
ipxnet_repr_len, /* len_string_repr */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger, /* set_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger, /* get_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2001-02-01 20:21:25 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
u_cmp_gt,
|
|
|
|
u_cmp_ge,
|
|
|
|
u_cmp_lt,
|
|
|
|
u_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
cmp_bitwise_and,
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2001-07-13 00:55:58 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2001-02-01 20:21:25 +00:00
|
|
|
};
|
|
|
|
|
2002-12-19 02:58:53 +00:00
|
|
|
static ftype_t framenum_type = {
|
2006-05-02 14:26:17 +00:00
|
|
|
FT_FRAMENUM, /* ftype */
|
2003-06-11 21:24:54 +00:00
|
|
|
"FT_FRAMENUM", /* name */
|
|
|
|
"frame number", /* pretty_name */
|
|
|
|
4, /* wire_size */
|
|
|
|
int_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
2010-04-30 21:40:39 +00:00
|
|
|
uint_from_unparsed, /* val_from_unparsed */
|
2003-07-25 03:44:05 +00:00
|
|
|
NULL, /* val_from_string */
|
2005-10-31 02:42:22 +00:00
|
|
|
uinteger_to_repr, /* val_to_string_repr */
|
|
|
|
uinteger_repr_len, /* len_string_repr */
|
2002-12-19 02:58:53 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
set_uinteger, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* set_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* set_value_floating */
|
2002-12-19 02:58:53 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value */
|
2007-01-18 11:02:26 +00:00
|
|
|
get_uinteger, /* get_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
2004-08-22 00:31:58 +00:00
|
|
|
NULL, /* get_value_integer64 */
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* get_value_floating */
|
2002-12-19 02:58:53 +00:00
|
|
|
|
|
|
|
cmp_eq,
|
|
|
|
cmp_ne,
|
|
|
|
u_cmp_gt,
|
|
|
|
u_cmp_ge,
|
|
|
|
u_cmp_lt,
|
|
|
|
u_cmp_le,
|
2004-02-27 12:00:32 +00:00
|
|
|
NULL, /* cmp_bitwise_and */
|
2003-08-27 15:23:11 +00:00
|
|
|
NULL, /* cmp_contains */
|
2003-12-06 16:35:20 +00:00
|
|
|
NULL, /* cmp_matches */
|
2002-12-19 02:58:53 +00:00
|
|
|
|
2003-06-11 21:24:54 +00:00
|
|
|
NULL, /* len */
|
|
|
|
NULL, /* slice */
|
2002-12-19 02:58:53 +00:00
|
|
|
};
|
2001-02-01 20:21:25 +00:00
|
|
|
|
2011-05-08 10:23:53 +00:00
|
|
|
static ftype_t eui64_type = {
|
|
|
|
FT_EUI64, /* ftype */
|
|
|
|
"FT_EUI64", /* name */
|
|
|
|
"EUI64 address", /* pretty_name */
|
|
|
|
FT_EUI64_LEN, /* wire_size */
|
|
|
|
int64_fvalue_new, /* new_value */
|
|
|
|
NULL, /* free_value */
|
|
|
|
eui64_from_unparsed, /* val_from_unparsed */
|
|
|
|
NULL, /* val_from_string */
|
|
|
|
eui64_to_repr, /* val_to_string_repr */
|
|
|
|
eui64_repr_len, /* len_string_repr */
|
|
|
|
|
|
|
|
NULL, /* set_value */
|
|
|
|
NULL, /* set_value_uinteger */
|
|
|
|
NULL, /* set_value_sinteger */
|
|
|
|
set_integer64, /* set_value_integer64 */
|
|
|
|
NULL, /* set_value_floating */
|
|
|
|
|
|
|
|
NULL, /* get_value */
|
|
|
|
NULL, /* get_value_uinteger */
|
|
|
|
NULL, /* get_value_sinteger */
|
|
|
|
get_integer64, /* get_value_integer64 */
|
|
|
|
NULL, /* get_value_floating */
|
|
|
|
|
|
|
|
cmp_eq64,
|
|
|
|
cmp_ne64,
|
|
|
|
u_cmp_gt64,
|
|
|
|
u_cmp_ge64,
|
|
|
|
u_cmp_lt64,
|
|
|
|
u_cmp_le64,
|
|
|
|
cmp_bitwise_and64,
|
|
|
|
NULL, /* cmp_contains */
|
|
|
|
NULL, /* cmp_matches */
|
|
|
|
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2001-02-01 20:21:25 +00:00
|
|
|
ftype_register(FT_UINT8, &uint8_type);
|
|
|
|
ftype_register(FT_UINT16, &uint16_type);
|
|
|
|
ftype_register(FT_UINT24, &uint24_type);
|
|
|
|
ftype_register(FT_UINT32, &uint32_type);
|
2004-08-22 00:31:58 +00:00
|
|
|
ftype_register(FT_UINT64, &uint64_type);
|
2001-02-01 20:21:25 +00:00
|
|
|
ftype_register(FT_INT8, &int8_type);
|
|
|
|
ftype_register(FT_INT16, &int16_type);
|
|
|
|
ftype_register(FT_INT24, &int24_type);
|
|
|
|
ftype_register(FT_INT32, &int32_type);
|
2004-08-22 00:31:58 +00:00
|
|
|
ftype_register(FT_INT64, &int64_type);
|
2001-02-01 20:21:25 +00:00
|
|
|
ftype_register(FT_BOOLEAN, &boolean_type);
|
|
|
|
ftype_register(FT_IPXNET, &ipxnet_type);
|
2002-12-19 02:58:53 +00:00
|
|
|
ftype_register(FT_FRAMENUM, &framenum_type);
|
2011-05-08 10:23:53 +00:00
|
|
|
ftype_register(FT_EUI64, &eui64_type);
|
2001-02-01 20:21:25 +00:00
|
|
|
}
|