epan/dfilter/drange.c

   1 /* drange.c
   2  * Routines for providing general range support to the dfilter library
   3  *
   4  * $Id$
   5  *
   6  * Copyright (c) 2000 by Ed Warnicke <hagbard@physics.rutgers.edu>
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs
  10  * Copyright 1999 Gerald Combs
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #include "config.h"
  27
  28 #include "drange.h"
  29
  30 /* drange_node constructor */
  31 drange_node*
  32 drange_node_new(void)
  33 {
  34   drange_node* new_range_node;
  35
  36   new_range_node = g_new(drange_node,1);
  37   new_range_node->start_offset = 0;
  38   new_range_node->length = 0;
  39   new_range_node->end_offset = 0;
  40   new_range_node->ending = DRANGE_NODE_END_T_UNINITIALIZED;
  41   return new_range_node;
  42 }
  43
  44 static drange_node*
  45 drange_node_dup(drange_node *org)
  46 {
  47   drange_node *new_range_node;
  48
  49   if (!org)
  50     return NULL;
  51
  52   new_range_node = g_new(drange_node,1);
  53   new_range_node->start_offset = org->start_offset;
  54   new_range_node->length = org->length;
  55   new_range_node->end_offset = org->end_offset;
  56   new_range_node->ending = org->ending;
  57   return new_range_node;
  58 }
  59
  60 /* drange_node destructor */
  61 void
  62 drange_node_free(drange_node* drnode)
  63 {
  64   g_free(drnode);
  65 }
  66
  67 /* drange_node accessors */
  68 gint
  69 drange_node_get_start_offset(drange_node* drnode)
  70 {
  71   g_assert(drnode->ending != DRANGE_NODE_END_T_UNINITIALIZED);
  72   return drnode->start_offset;
  73 }
  74
  75 gint
  76 drange_node_get_length(drange_node* drnode)
  77 {
  78   g_assert(drnode->ending == DRANGE_NODE_END_T_LENGTH);
  79   return drnode->length;
  80 }
  81
  82 gint
  83 drange_node_get_end_offset(drange_node* drnode)
  84 {
  85   g_assert(drnode->ending == DRANGE_NODE_END_T_OFFSET);
  86   return drnode->end_offset;
  87 }
  88
  89 drange_node_end_t
  90 drange_node_get_ending(drange_node* drnode)
  91 {
  92   g_assert(drnode->ending != DRANGE_NODE_END_T_UNINITIALIZED);
  93   return drnode->ending;
  94 }
  95
  96 /* drange_node mutators */
  97 void
  98 drange_node_set_start_offset(drange_node* drnode, gint offset)
  99 {
 100   drnode->start_offset = offset;
 101 }
 102
 103 void
 104 drange_node_set_length(drange_node* drnode, gint length)
 105 {
 106   drnode->length = length;
 107   drnode->ending = DRANGE_NODE_END_T_LENGTH;
 108 }
 109
 110 void
 111 drange_node_set_end_offset(drange_node* drnode, gint offset)
 112 {
 113   drnode->end_offset = offset;
 114   drnode->ending = DRANGE_NODE_END_T_OFFSET;
 115 }
 116
 117
 118 void
 119 drange_node_set_to_the_end(drange_node* drnode)
 120 {
 121   drnode->ending = DRANGE_NODE_END_T_TO_THE_END;
 122 }
 123
 124 /* drange constructor */
 125 drange_t *
 126 drange_new(void)
 127 {
 128   drange_t * new_drange;
 129   new_drange = g_new(drange_t,1);
 130   new_drange->range_list = NULL;
 131   new_drange->has_total_length = TRUE;
 132   new_drange->total_length = 0;
 133   new_drange->min_start_offset = G_MAXINT;
 134   new_drange->max_start_offset = G_MININT;
 135   return new_drange;
 136 }
 137
 138 static void
 139 drange_append_wrapper(gpointer data, gpointer user_data)
 140 {
 141         drange_node *drnode = (drange_node *)data;
 142         drange_t        *dr             = (drange_t *)user_data;
 143
 144         drange_append_drange_node(dr, drnode);
 145 }
 146
 147 drange_t *
 148 drange_new_from_list(GSList *list)
 149 {
 150         drange_t        *new_drange;
 151
 152         new_drange = drange_new();
 153         g_slist_foreach(list, drange_append_wrapper, new_drange);
 154         return new_drange;
 155 }
 156
 157 drange_t *
 158 drange_dup(drange_t *org)
 159 {
 160         drange_t *new_drange;
 161         GSList *p;
 162
 163         if (!org)
 164                 return NULL;
 165
 166         new_drange = drange_new();
 167         for (p = org->range_list; p; p = p->next) {
 168                 drange_node *drnode = (drange_node *)p->data;
 169                 drange_append_drange_node(new_drange, drange_node_dup(drnode));
 170         }
 171         return new_drange;
 172 }
 173
 174
 175 static void
 176 drange_node_free_wrapper(gpointer data, gpointer userdata _U_)
 177 {
 178   g_free(data);
 179 }
 180
 181 /* drange destructor */
 182 void
 183 drange_free(drange_t * dr)
 184 {
 185   drange_node_free_list(dr->range_list);
 186   g_free(dr);
 187 }
 188
 189 /* Call drange_node destructor on all list items */
 190 void
 191 drange_node_free_list(GSList* list)
 192 {
 193   g_slist_foreach(list, drange_node_free_wrapper, NULL);
 194 }
 195
 196 /* drange accessors */
 197 gboolean drange_has_total_length(drange_t * dr){ return dr->has_total_length; }
 198 gint drange_get_total_length(drange_t * dr) { return dr->total_length; }
 199 gint drange_get_min_start_offset(drange_t * dr) { return dr->min_start_offset; }
 200 gint drange_get_max_start_offset(drange_t * dr) { return dr->max_start_offset; }
 201
 202 static void
 203 update_drange_with_node(drange_t *dr, drange_node *drnode)
 204 {
 205     if(drnode->ending == DRANGE_NODE_END_T_TO_THE_END){
 206       dr->has_total_length = FALSE;
 207     }
 208     else if(dr->has_total_length){
 209       dr->total_length += drnode->length;
 210     }
 211     if(drnode->start_offset < dr->min_start_offset){
 212       dr->min_start_offset = drnode->start_offset;
 213     }
 214     if(drnode->start_offset > dr->max_start_offset){
 215       dr->max_start_offset = drnode->start_offset;
 216     }
 217 }
 218
 219 /* drange mutators */
 220 void
 221 drange_prepend_drange_node(drange_t * dr, drange_node* drnode)
 222 {
 223   if(drnode != NULL){
 224     dr->range_list = g_slist_prepend(dr->range_list,drnode);
 225     update_drange_with_node(dr, drnode);
 226   }
 227 }
 228
 229 void
 230 drange_append_drange_node(drange_t * dr, drange_node* drnode)
 231 {
 232   if(drnode != NULL){
 233     dr->range_list = g_slist_append(dr->range_list,drnode);
 234     update_drange_with_node(dr, drnode);
 235   }
 236 }
 237
 238 void
 239 drange_foreach_drange_node(drange_t * dr, GFunc func, gpointer funcdata)
 240 {
 241   g_slist_foreach(dr->range_list,func,funcdata);
 242 }