packet-range.c

   1 /* packet-range.c
   2  * Packet range routines (save, print, ...)
   3  *
   4  * $Id$
   5  *
   6  * Dick Gooris <gooris@lucent.com>
   7  * Ulf Lamping <ulf.lamping@web.de>
   8  *
   9  * Wireshark - Network traffic analyzer
  10  * By Gerald Combs <gerald@wireshark.org>
  11  * Copyright 1998 Gerald Combs
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35
  36 #include <glib.h>
  37
  38 #include <epan/frame_data.h>
  39
  40 #include "globals.h"
  41
  42 #include "packet-range.h"
  43
  44 /* (re-)calculate the packet counts (except the user specified range) */
  45 static void packet_range_calc(packet_range_t *range) {
  46     guint32       framenum;
  47     guint32       mark_low;
  48     guint32       mark_high;
  49     guint32       displayed_mark_low;
  50     guint32       displayed_mark_high;
  51     frame_data    *packet;
  52
  53
  54     range->selected_packet        = 0L;
  55
  56     mark_low                      = 0L;
  57     mark_high                     = 0L;
  58     range->mark_range_cnt         = 0L;
  59     range->ignored_cnt            = 0L;
  60     range->ignored_marked_cnt     = 0L;
  61     range->ignored_mark_range_cnt = 0L;
  62     range->ignored_user_range_cnt = 0L;
  63
  64     displayed_mark_low            = 0L;
  65     displayed_mark_high           = 0L;
  66     range->displayed_cnt          = 0L;
  67     range->displayed_marked_cnt   = 0L;
  68     range->displayed_mark_range_cnt=0L;
  69     range->displayed_ignored_cnt            = 0L;
  70     range->displayed_ignored_marked_cnt     = 0L;
  71     range->displayed_ignored_mark_range_cnt = 0L;
  72     range->displayed_ignored_user_range_cnt = 0L;
  73
  74     /* This doesn't work unless you have a full set of frame_data
  75      * structures for all packets in the capture, which is not,
  76      * for example, the case when TShark is doing a one-pass
  77      * read of a file or a live capture.
  78      */
  79     if (cfile.frames != NULL) {
  80         /* The next for-loop is used to obtain the amount of packets
  81          * to be processed and is used to present the information in
  82          * the Save/Print As widget.
  83          * We have different types of ranges: All the packets, the number
  84          * of packets of a marked range, a single packet, and a user specified
  85          * packet range. The last one is not calculated here since this
  86          * data must be entered in the widget by the user.
  87          */
  88
  89         for(framenum = 1; framenum <= cfile.count; framenum++) {
  90             packet = frame_data_sequence_find(cfile.frames, framenum);
  91
  92             if (cfile.current_frame == packet) {
  93                 range->selected_packet = framenum;
  94             }
  95             if (packet->flags.passed_dfilter) {
  96                 range->displayed_cnt++;
  97             }
  98             if (packet->flags.marked) {
  99                 if (packet->flags.ignored) {
 100                     range->ignored_marked_cnt++;
 101                 }
 102                 if (packet->flags.passed_dfilter) {
 103                     range->displayed_marked_cnt++;
 104                     if (packet->flags.ignored) {
 105                         range->displayed_ignored_marked_cnt++;
 106                     }
 107                     if (displayed_mark_low == 0) {
 108                        displayed_mark_low = framenum;
 109                     }
 110                     if (framenum > displayed_mark_high) {
 111                        displayed_mark_high = framenum;
 112                     }
 113                 }
 114
 115                 if (mark_low == 0) {
 116                    mark_low = framenum;
 117                 }
 118                 if (framenum > mark_high) {
 119                    mark_high = framenum;
 120                 }
 121             }
 122             if (packet->flags.ignored) {
 123                 range->ignored_cnt++;
 124                 if (packet->flags.passed_dfilter) {
 125                     range->displayed_ignored_cnt++;
 126                 }
 127             }
 128         }
 129
 130         for(framenum = 1; framenum <= cfile.count; framenum++) {
 131             packet = frame_data_sequence_find(cfile.frames, framenum);
 132
 133             if (framenum >= mark_low &&
 134                 framenum <= mark_high)
 135             {
 136                 range->mark_range_cnt++;
 137                 if (packet->flags.ignored) {
 138                     range->ignored_mark_range_cnt++;
 139                 }
 140             }
 141
 142             if (framenum >= displayed_mark_low &&
 143                 framenum <= displayed_mark_high)
 144             {
 145                 if (packet->flags.passed_dfilter) {
 146                     range->displayed_mark_range_cnt++;
 147                     if (packet->flags.ignored) {
 148                         range->displayed_ignored_mark_range_cnt++;
 149                     }
 150                 }
 151             }
 152         }
 153
 154 #if 0
 155         /* in case we marked just one packet, we add 1. */
 156         if (cfile.marked_count != 0) {
 157             range->mark_range = mark_high - mark_low + 1;
 158         }
 159
 160         /* in case we marked just one packet, we add 1. */
 161         if (range->displayed_marked_cnt != 0) {
 162             range->displayed_mark_range = displayed_mark_high - displayed_mark_low + 1;
 163         }
 164 #endif
 165     }
 166 }
 167
 168
 169 /* (re-)calculate the user specified packet range counts */
 170 static void packet_range_calc_user(packet_range_t *range) {
 171     guint32       framenum;
 172     frame_data    *packet;
 173
 174     range->user_range_cnt             = 0L;
 175     range->ignored_user_range_cnt     = 0L;
 176     range->displayed_user_range_cnt   = 0L;
 177     range->displayed_ignored_user_range_cnt = 0L;
 178
 179     /* This doesn't work unless you have a full set of frame_data
 180      * structures for all packets in the capture, which is not,
 181      * for example, the case when TShark is doing a one-pass
 182      * read of a file or a live capture.
 183      */
 184     if (cfile.frames != NULL) {
 185         for(framenum = 1; framenum <= cfile.count; framenum++) {
 186             packet = frame_data_sequence_find(cfile.frames, framenum);
 187
 188             if (value_is_in_range(range->user_range, framenum)) {
 189                 range->user_range_cnt++;
 190                 if (packet->flags.ignored) {
 191                     range->ignored_user_range_cnt++;
 192                 }
 193                 if (packet->flags.passed_dfilter) {
 194                     range->displayed_user_range_cnt++;
 195                     if (packet->flags.ignored) {
 196                         range->displayed_ignored_user_range_cnt++;
 197                     }
 198                 }
 199             }
 200         }
 201     }
 202 }
 203
 204
 205 /* init the range struct */
 206 void packet_range_init(packet_range_t *range) {
 207
 208     range->process            = range_process_all;
 209     range->process_filtered   = FALSE;
 210     range->remove_ignored     = FALSE;
 211     range->user_range         = range_empty();
 212
 213     /* calculate all packet range counters */
 214     packet_range_calc(range);
 215     packet_range_calc_user(range);
 216 }
 217
 218 /* check whether the packet range is OK */
 219 convert_ret_t packet_range_check(packet_range_t *range) {
 220     if (range->process == range_process_user_range && range->user_range == NULL) {
 221         /* Not valid - return the error. */
 222         return range->user_range_status;
 223     }
 224     return CVT_NO_ERROR;
 225 }
 226
 227 /* init the processing run */
 228 void packet_range_process_init(packet_range_t *range) {
 229     /* Check that, if an explicit range was selected, it's valid. */
 230     /* "enumeration" values */
 231     range->marked_range_active    = FALSE;
 232     range->selected_done          = FALSE;
 233
 234     if (range->process_filtered == FALSE) {
 235         range->marked_range_left = range->mark_range_cnt;
 236     } else {
 237         range->marked_range_left = range->displayed_mark_range_cnt;
 238     }
 239 }
 240
 241 /* do we have to process all packets? */
 242 gboolean packet_range_process_all(packet_range_t *range) {
 243     return range->process == range_process_all && !range->process_filtered && !range->remove_ignored;
 244 }
 245
 246 /* do we have to process this packet? */
 247 range_process_e packet_range_process_packet(packet_range_t *range, frame_data *fdata) {
 248
 249     if (range->remove_ignored && fdata->flags.ignored) {
 250         return range_process_next;
 251     }
 252
 253     switch(range->process) {
 254     case(range_process_all):
 255         break;
 256     case(range_process_selected):
 257         if (range->selected_done) {
 258           return range_processing_finished;
 259         }
 260         if (fdata->num != cfile.current_frame->num) {
 261           return range_process_next;
 262         }
 263         range->selected_done = TRUE;
 264         break;
 265     case(range_process_marked):
 266         if (fdata->flags.marked == FALSE) {
 267           return range_process_next;
 268         }
 269         break;
 270     case(range_process_marked_range):
 271         if (range->marked_range_left == 0) {
 272           return range_processing_finished;
 273         }
 274         if (fdata->flags.marked == TRUE) {
 275           range->marked_range_active = TRUE;
 276         }
 277         if (range->marked_range_active == FALSE ) {
 278           return range_process_next;
 279         }
 280         if (!range->process_filtered ||
 281           (range->process_filtered && fdata->flags.passed_dfilter == TRUE))
 282         {
 283           range->marked_range_left--;
 284         }
 285         break;
 286     case(range_process_user_range):
 287         if (value_is_in_range(range->user_range, fdata->num) == FALSE) {
 288           return range_process_next;
 289         }
 290         break;
 291     default:
 292         g_assert_not_reached();
 293     }
 294
 295     /* this packet has to pass the display filter but didn't? -> try next */
 296     if (range->process_filtered && fdata->flags.passed_dfilter == FALSE) {
 297         return range_process_next;
 298     }
 299
 300     /* We fell through the conditions above, so we accept this packet */
 301     return range_process_this;
 302 }
 303
 304
 305 /******************** Range Entry Parser *********************************/
 306
 307 /* Converts a range string to a user range.
 308  * The parameter 'es' points to the string to be converted, and is defined in
 309  * the Save/Print-As widget.
 310  */
 311
 312 void packet_range_convert_str(packet_range_t *range, const gchar *es)
 313 {
 314     range_t *new_range;
 315     convert_ret_t ret;
 316
 317     if (range->user_range != NULL)
 318         g_free(range->user_range);
 319     ret = range_convert_str(&new_range, es, cfile.count);
 320     if (ret != CVT_NO_ERROR) {
 321         /* range isn't valid */
 322         range->user_range                 = NULL;
 323         range->user_range_status          = ret;
 324         range->user_range_cnt             = 0L;
 325         range->ignored_user_range_cnt     = 0L;
 326         range->displayed_user_range_cnt   = 0L;
 327         range->displayed_ignored_user_range_cnt = 0L;
 328         return;
 329     }
 330     range->user_range = new_range;
 331
 332     /* calculate new user specified packet range counts */
 333     packet_range_calc_user(range);
 334 } /* packet_range_convert_str */