Enable slices of [i-j], where i is start offset and j is end offset,
inclusive. That is, [0-1] is a slice of 2 bytes. svn path=/trunk/; revision=3092
This commit is contained in:
Gilbert Ramirez
parent
c88e7b5a63
commit
b24dff17bd
|
|
@ -1,7 +1,7 @@
|
|||
/* drange.c
|
||||
* Routines for providing general range support to the dfilter library
|
||||
*
|
||||
* $Id: drange.c,v 1.1 2001/02/27 19:23:28 gram Exp $
|
||||
* $Id: drange.c,v 1.2 2001/03/02 17:04:23 gram Exp $
|
||||
*
|
||||
* Copyright (c) 2000 by Ed Warnicke <hagbard@physics.rutgers.edu>
|
||||
*
|
||||
|
|
@ -32,9 +32,10 @@ drange_node_new(void)
|
|||
drange_node* new_range_node;
|
||||
|
||||
new_range_node = g_malloc(sizeof(drange_node));
|
||||
new_range_node->offset = 0;
|
||||
new_range_node->start_offset = 0;
|
||||
new_range_node->length = 0;
|
||||
new_range_node->to_the_end = FALSE;
|
||||
new_range_node->end_offset = 0;
|
||||
new_range_node->ending = UNINITIALIZED;
|
||||
return new_range_node;
|
||||
}
|
||||
|
||||
|
|
@ -47,41 +48,59 @@ drange_node_free(drange_node* drnode)
|
|||
|
||||
/* drange_node accessors */
|
||||
gint
|
||||
drange_node_get_offset(drange_node* drnode)
|
||||
drange_node_get_start_offset(drange_node* drnode)
|
||||
{
|
||||
return drnode->offset;
|
||||
g_assert(drnode->ending != UNINITIALIZED);
|
||||
return drnode->start_offset;
|
||||
}
|
||||
|
||||
gint
|
||||
drange_node_get_length(drange_node* drnode)
|
||||
{
|
||||
g_assert(drnode->ending == LENGTH);
|
||||
return drnode->length;
|
||||
}
|
||||
|
||||
gboolean
|
||||
drange_node_get_to_the_end(drange_node* drnode)
|
||||
gint
|
||||
drange_node_get_end_offset(drange_node* drnode)
|
||||
{
|
||||
return drnode->to_the_end;
|
||||
g_assert(drnode->ending == OFFSET);
|
||||
return drnode->end_offset;
|
||||
}
|
||||
|
||||
drange_node_end_t
|
||||
drange_node_get_ending(drange_node* drnode)
|
||||
{
|
||||
g_assert(drnode->ending != UNINITIALIZED);
|
||||
return drnode->ending;
|
||||
}
|
||||
|
||||
/* drange_node mutators */
|
||||
void
|
||||
drange_node_set_offset(drange_node* drnode, gint offset)
|
||||
drange_node_set_start_offset(drange_node* drnode, gint offset)
|
||||
{
|
||||
drnode->offset = offset;
|
||||
drnode->start_offset = offset;
|
||||
}
|
||||
|
||||
void
|
||||
drange_node_set_length(drange_node* drnode, gint length)
|
||||
{
|
||||
drnode->length = length;
|
||||
drnode->to_the_end = FALSE;
|
||||
drnode->ending = LENGTH;
|
||||
}
|
||||
|
||||
void
|
||||
drange_node_set_to_the_end(drange_node* drnode, gboolean to_the_end)
|
||||
drange_node_set_end_offset(drange_node* drnode, gint offset)
|
||||
{
|
||||
drnode->to_the_end = to_the_end;
|
||||
drnode->end_offset = offset;
|
||||
drnode->ending = OFFSET;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
drange_node_set_to_the_end(drange_node* drnode)
|
||||
{
|
||||
drnode->ending = TO_THE_END;
|
||||
}
|
||||
|
||||
/* drange constructor */
|
||||
|
|
@ -93,8 +112,8 @@ drange_new(void)
|
|||
new_drange->range_list = NULL;
|
||||
new_drange->has_total_length = TRUE;
|
||||
new_drange->total_length = 0;
|
||||
new_drange->min_offset = G_MAXINT;
|
||||
new_drange->max_offset = G_MININT;
|
||||
new_drange->min_start_offset = G_MAXINT;
|
||||
new_drange->max_start_offset = G_MININT;
|
||||
return new_drange;
|
||||
}
|
||||
|
||||
|
|
@ -142,23 +161,23 @@ drange_node_free_list(GSList* list)
|
|||
/* drange accessors */
|
||||
gboolean drange_has_total_length(drange* dr){ return dr->has_total_length; }
|
||||
gint drange_get_total_length(drange* dr) { return dr->total_length; }
|
||||
gint drange_get_min_offset(drange* dr) { return dr->min_offset; }
|
||||
gint drange_get_max_offset(drange* dr) { return dr->max_offset; }
|
||||
gint drange_get_min_start_offset(drange* dr) { return dr->min_start_offset; }
|
||||
gint drange_get_max_start_offset(drange* dr) { return dr->max_start_offset; }
|
||||
|
||||
static void
|
||||
update_drange_with_node(drange *dr, drange_node *drnode)
|
||||
{
|
||||
if(drnode->to_the_end){
|
||||
if(drnode->ending == TO_THE_END){
|
||||
dr->has_total_length = FALSE;
|
||||
}
|
||||
else if(dr->has_total_length){
|
||||
dr->total_length += drnode->length;
|
||||
}
|
||||
if(drnode->offset < dr->min_offset){
|
||||
dr->min_offset = drnode->offset;
|
||||
if(drnode->start_offset < dr->min_start_offset){
|
||||
dr->min_start_offset = drnode->start_offset;
|
||||
}
|
||||
if(drnode->offset > dr->max_offset){
|
||||
dr->max_offset = drnode->offset;
|
||||
if(drnode->start_offset > dr->max_start_offset){
|
||||
dr->max_start_offset = drnode->start_offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/* drange.h
|
||||
* Routines for providing general range support to the dfilter library
|
||||
*
|
||||
* $Id: drange.h,v 1.1 2001/02/27 19:23:28 gram Exp $
|
||||
* $Id: drange.h,v 1.2 2001/03/02 17:04:23 gram Exp $
|
||||
*
|
||||
* Copyright (c) 2000 by Ed Warnicke <hagbard@physics.rutgers.edu>
|
||||
*
|
||||
|
|
@ -36,18 +36,26 @@
|
|||
* here.
|
||||
*/
|
||||
|
||||
typedef enum {
|
||||
UNINITIALIZED,
|
||||
LENGTH,
|
||||
OFFSET,
|
||||
TO_THE_END
|
||||
} drange_node_end_t;
|
||||
|
||||
typedef struct _drange_node {
|
||||
gint offset;
|
||||
gint length;
|
||||
gboolean to_the_end;
|
||||
gint start_offset;
|
||||
gint length;
|
||||
gint end_offset;
|
||||
drange_node_end_t ending;
|
||||
} drange_node;
|
||||
|
||||
typedef struct _drange {
|
||||
GSList* range_list;
|
||||
gboolean has_total_length;
|
||||
gint total_length;
|
||||
gint min_offset;
|
||||
gint max_offset;
|
||||
gint min_start_offset;
|
||||
gint max_start_offset;
|
||||
} drange;
|
||||
|
||||
/* drange_node constructor */
|
||||
|
|
@ -60,14 +68,16 @@ void drange_node_free(drange_node* drnode);
|
|||
void drange_node_free_list(GSList* list);
|
||||
|
||||
/* drange_node accessors */
|
||||
gint drange_node_get_offset(drange_node* drnode);
|
||||
gint drange_node_get_start_offset(drange_node* drnode);
|
||||
gint drange_node_get_length(drange_node* drnode);
|
||||
gboolean drange_node_get_to_the_end(drange_node* drnode);
|
||||
gint drange_node_get_end_offset(drange_node* drnode);
|
||||
drange_node_end_t drange_node_get_ending(drange_node* drnode);
|
||||
|
||||
/* drange_node mutators */
|
||||
void drange_node_set_offset(drange_node* drnode, gint offset);
|
||||
void drange_node_set_start_offset(drange_node* drnode, gint offset);
|
||||
void drange_node_set_length(drange_node* drnode, gint length);
|
||||
void drange_node_set_to_the_end(drange_node* drnode, gboolean to_the_end);
|
||||
void drange_node_set_end_offset(drange_node* drnode, gint offset);
|
||||
void drange_node_set_to_the_end(drange_node* drnode);
|
||||
|
||||
/* drange constructor */
|
||||
drange* drange_new();
|
||||
|
|
@ -81,8 +91,8 @@ void drange_free(drange* dr);
|
|||
/* drange accessors */
|
||||
gboolean drange_has_total_length(drange* dr);
|
||||
gint drange_get_total_length(drange* dr);
|
||||
gint drange_get_min_offset(drange* dr);
|
||||
gint drange_get_max_offset(drange* dr);
|
||||
gint drange_get_min_start_offset(drange* dr);
|
||||
gint drange_get_max_start_offset(drange* dr);
|
||||
|
||||
/* drange mutators */
|
||||
void drange_append_drange_node(drange* dr, drange_node* drnode);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: grammar.lemon,v 1.2 2001/02/27 19:23:28 gram Exp $ */
|
||||
/* $Id: grammar.lemon,v 1.3 2001/03/02 17:04:23 gram Exp $ */
|
||||
|
||||
%include {
|
||||
#ifdef HAVE_CONFIG_H
|
||||
|
|
@ -11,8 +11,6 @@
|
|||
#include "sttype-test.h"
|
||||
#include "drange.h"
|
||||
|
||||
/*extern char *df_text;*/
|
||||
|
||||
/* End of C code */
|
||||
}
|
||||
|
||||
|
|
@ -180,30 +178,30 @@ drnode_list(L) ::= drnode_list(P) COMMA drnode(D).
|
|||
drnode(D) ::= INTEGER(X) COLON INTEGER(Y).
|
||||
{
|
||||
D = drange_node_new();
|
||||
drange_node_set_offset(D, stnode_value(X));
|
||||
drange_node_set_start_offset(D, stnode_value(X));
|
||||
drange_node_set_length(D, stnode_value(Y));
|
||||
|
||||
stnode_free(X);
|
||||
stnode_free(Y);
|
||||
}
|
||||
|
||||
/* x,y == offset:(offset-1)
|
||||
/* x-y == offset:offset */
|
||||
drnode(D) ::= INTEGER(X) HYPHEN INTEGER(Y).
|
||||
{
|
||||
D = drange_node_new();
|
||||
drange_node_set_offset(D, stnode_value(X));
|
||||
drange_node_set_length(D, stnode_value(Y));
|
||||
drange_node_set_start_offset(D, stnode_value(X));
|
||||
drange_node_set_end_offset(D, stnode_value(Y));
|
||||
|
||||
stnode_free(X);
|
||||
stnode_free(Y);
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
/* :y == from start to offset */
|
||||
drnode(D) ::= COLON INTEGER(Y).
|
||||
{
|
||||
D = drange_node_new();
|
||||
drange_node_set_offset(D, 0);
|
||||
drange_node_set_start_offset(D, 0);
|
||||
drange_node_set_length(D, stnode_value(Y));
|
||||
|
||||
stnode_free(Y);
|
||||
|
|
@ -213,8 +211,8 @@ drnode(D) ::= COLON INTEGER(Y).
|
|||
drnode(D) ::= INTEGER(X) COLON.
|
||||
{
|
||||
D = drange_node_new();
|
||||
drange_node_set_offset(D, stnode_value(X));
|
||||
drange_node_set_to_the_end(D, TRUE);
|
||||
drange_node_set_start_offset(D, stnode_value(X));
|
||||
drange_node_set_to_the_end(D);
|
||||
|
||||
stnode_free(X);
|
||||
}
|
||||
|
|
@ -223,7 +221,7 @@ drnode(D) ::= INTEGER(X) COLON.
|
|||
drnode(D) ::= INTEGER(X).
|
||||
{
|
||||
D = drange_node_new();
|
||||
drange_node_set_offset(D, stnode_value(X));
|
||||
drange_node_set_start_offset(D, stnode_value(X));
|
||||
drange_node_set_length(D, 1);
|
||||
|
||||
stnode_free(X);
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
%{
|
||||
/*
|
||||
* $Id: scanner.l,v 1.3 2001/02/27 19:23:28 gram Exp $
|
||||
* $Id: scanner.l,v 1.4 2001/03/02 17:04:23 gram Exp $
|
||||
*
|
||||
* Ethereal - Network traffic analyzer
|
||||
* By Gerald Combs <gerald@zing.org>
|
||||
|
|
@ -50,7 +50,8 @@ static gboolean str_to_guint32(char *s, guint32* pint);
|
|||
|
||||
%}
|
||||
|
||||
%x RANGE
|
||||
%x RANGE_INT
|
||||
%x RANGE_PUNCT
|
||||
|
||||
BWCHARS [[:alnum:]\[\]\-_.+!@#%^&*=/:]
|
||||
INITVAR [_A-Za-z]
|
||||
|
|
@ -87,21 +88,36 @@ VARCHARS [[:alnum:]_]
|
|||
"or" return simple(TOKEN_TEST_OR);
|
||||
|
||||
|
||||
"[" {
|
||||
BEGIN(RANGE);
|
||||
"[" {
|
||||
BEGIN(RANGE_INT);
|
||||
return simple(TOKEN_LBRACKET);
|
||||
}
|
||||
|
||||
<RANGE>[+-]?[[:digit:]]+ {
|
||||
<RANGE_INT>[+-]?[[:digit:]]+ {
|
||||
BEGIN(RANGE_PUNCT);
|
||||
return set_lval_int(TOKEN_INTEGER, yytext);
|
||||
}
|
||||
<RANGE>[+-]?0x[[:xdigit:]]+ {
|
||||
<RANGE_INT>[+-]?0x[[:xdigit:]]+ {
|
||||
BEGIN(RANGE_PUNCT);
|
||||
return set_lval_int(TOKEN_INTEGER, yytext);
|
||||
}
|
||||
<RANGE>":" return simple(TOKEN_COLON);
|
||||
<RANGE>"," return simple(TOKEN_COMMA);
|
||||
|
||||
<RANGE>"]" {
|
||||
<RANGE_INT,RANGE_PUNCT>":" {
|
||||
BEGIN(RANGE_INT);
|
||||
return simple(TOKEN_COLON);
|
||||
}
|
||||
|
||||
<RANGE_PUNCT>"-" {
|
||||
BEGIN(RANGE_INT);
|
||||
return simple(TOKEN_HYPHEN);
|
||||
}
|
||||
|
||||
<RANGE_INT,RANGE_PUNCT>"," {
|
||||
BEGIN(RANGE_INT);
|
||||
return simple(TOKEN_COMMA);
|
||||
}
|
||||
|
||||
<RANGE_INT,RANGE_PUNCT>"]" {
|
||||
BEGIN(INITIAL);
|
||||
return simple(TOKEN_RBRACKET);
|
||||
}
|
||||
|
|
@ -142,6 +158,7 @@ simple(int token)
|
|||
case TOKEN_RBRACKET:
|
||||
case TOKEN_COLON:
|
||||
case TOKEN_COMMA:
|
||||
case TOKEN_HYPHEN:
|
||||
case TOKEN_TEST_EQ:
|
||||
case TOKEN_TEST_NE:
|
||||
case TOKEN_TEST_GT:
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* $Id: semcheck.c,v 1.3 2001/02/27 19:23:28 gram Exp $
|
||||
* $Id: semcheck.c,v 1.4 2001/03/02 17:04:23 gram Exp $
|
||||
*
|
||||
* Ethereal - Network traffic analyzer
|
||||
* By Gerald Combs <gerald@zing.org>
|
||||
|
|
@ -310,8 +310,8 @@ check_relation_LHS_FIELD(dfwork_t *dfw, FtypeCanFunc can_func, stnode_t *st_node
|
|||
new_st = stnode_new(STTYPE_RANGE, NULL);
|
||||
|
||||
rn = drange_node_new();
|
||||
drange_node_set_offset(rn, 0);
|
||||
drange_node_set_to_the_end(rn, TRUE);
|
||||
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);
|
||||
|
||||
|
|
@ -417,8 +417,8 @@ check_relation_LHS_RANGE(dfwork_t *dfw, FtypeCanFunc can_func, stnode_t *st_node
|
|||
new_st = stnode_new(STTYPE_RANGE, NULL);
|
||||
|
||||
rn = drange_node_new();
|
||||
drange_node_set_offset(rn, 0);
|
||||
drange_node_set_to_the_end(rn, TRUE);
|
||||
drange_node_set_start_offset(rn, 0);
|
||||
drange_node_set_to_the_end(rn);
|
||||
/* st_arg2 is freed in this step */
|
||||
sttype_range_set1(new_st, st_arg2, rn);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* $Id: ftypes.c,v 1.3 2001/02/27 19:23:30 gram Exp $
|
||||
* $Id: ftypes.c,v 1.4 2001/03/02 17:04:25 gram Exp $
|
||||
*
|
||||
* Ethereal - Network traffic analyzer
|
||||
* By Gerald Combs <gerald@zing.org>
|
||||
|
|
@ -285,60 +285,78 @@ slice_func(gpointer data, gpointer user_data)
|
|||
{
|
||||
drange_node *drnode = data;
|
||||
slice_data_t *slice_data = user_data;
|
||||
gint offset;
|
||||
gint length;
|
||||
gint start_offset;
|
||||
gint length = 0;
|
||||
gint end_offset = 0;
|
||||
guint field_length;
|
||||
guint end_offset;
|
||||
gboolean to_end;
|
||||
fvalue_t *fv;
|
||||
drange_node_end_t ending;
|
||||
|
||||
if (slice_data->slice_failure) {
|
||||
return;
|
||||
}
|
||||
|
||||
offset = drange_node_get_offset(drnode);
|
||||
length = drange_node_get_length(drnode);
|
||||
to_end = drange_node_get_to_the_end(drnode);
|
||||
start_offset = drange_node_get_start_offset(drnode);
|
||||
ending = drange_node_get_ending(drnode);
|
||||
|
||||
fv = slice_data->fv;
|
||||
field_length = fvalue_length(fv);
|
||||
|
||||
/* g_debug("field_length=%u offset=%d length=%d",
|
||||
field_length, offset, length);*/
|
||||
|
||||
if (offset < 0) {
|
||||
offset = field_length + offset;
|
||||
/* Check for negative start */
|
||||
if (start_offset < 0) {
|
||||
start_offset = field_length + start_offset;
|
||||
}
|
||||
|
||||
if (to_end) {
|
||||
/* Check the end type, and set both end_offset and length */
|
||||
if (ending == TO_THE_END) {
|
||||
end_offset = field_length;
|
||||
length = end_offset - offset;
|
||||
length = end_offset - start_offset;
|
||||
}
|
||||
else {
|
||||
else if (ending == LENGTH) {
|
||||
length = drange_node_get_length(drnode);
|
||||
if (length < 0) {
|
||||
end_offset = field_length + length;
|
||||
if (end_offset >= offset) {
|
||||
length = end_offset - offset;
|
||||
if (end_offset > start_offset) {
|
||||
length = end_offset - start_offset + 1;
|
||||
}
|
||||
else {
|
||||
length = 0;
|
||||
slice_data->slice_failure = TRUE;
|
||||
return;
|
||||
}
|
||||
}
|
||||
else {
|
||||
end_offset = offset + length;
|
||||
end_offset = start_offset + length;
|
||||
}
|
||||
}
|
||||
else if (ending == OFFSET) {
|
||||
end_offset = drange_node_get_end_offset(drnode);
|
||||
if (end_offset < 0) {
|
||||
end_offset = field_length + end_offset;
|
||||
if (end_offset > start_offset) {
|
||||
length = end_offset - start_offset + 1;
|
||||
}
|
||||
else {
|
||||
slice_data->slice_failure = TRUE;
|
||||
return;
|
||||
}
|
||||
}
|
||||
else {
|
||||
length = end_offset - start_offset + 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
g_assert_not_reached();
|
||||
}
|
||||
|
||||
/* g_debug("(NEW) start_offset=%d length=%d end_offset=%d",
|
||||
start_offset, length, end_offset); */
|
||||
|
||||
/* g_debug("\t\t(NEW) offset=%d length=%d",
|
||||
offset, length);*/
|
||||
|
||||
if (offset > field_length || end_offset > field_length) {
|
||||
if (start_offset > field_length || end_offset > field_length) {
|
||||
slice_data->slice_failure = TRUE;
|
||||
return;
|
||||
}
|
||||
|
||||
fv->ftype->slice(fv, slice_data->bytes, offset, length);
|
||||
fv->ftype->slice(fv, slice_data->bytes, start_offset, length);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue