/* tap-iostat.c
* iostat 2002 Ronnie Sahlberg
*
- * $Id: tap-iostat.c,v 1.8 2003/04/29 08:47:20 sahlberg Exp $
+ * $Id$
*
- * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@ethereal.com>
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* 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.
- *
+ *
* 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.
- *
+ *
* 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.
#include <string.h>
#include "epan/epan_dissect.h"
#include "epan/packet_info.h"
-#include "tap.h"
-#include "register.h"
+#include <epan/tap.h>
+#include <epan/stat_cmd_args.h>
+#include <epan/strutil.h>
typedef struct _io_stat_t {
- gint32 interval; /* unit is ms */
+ gint64 interval; /* unit is us */
guint32 num_items;
struct _io_stat_item_t *items;
- char **filters;
-} io_stat_t;
-
-#define CALC_TYPE_BYTES 0
-#define CALC_TYPE_COUNT 1
-#define CALC_TYPE_SUM 2
-#define CALC_TYPE_MIN 3
-#define CALC_TYPE_MAX 4
-#define CALC_TYPE_AVG 5
+ const char **filters;
+} io_stat_t;
+
+#define CALC_TYPE_FRAMES 0
+#define CALC_TYPE_BYTES 1
+#define CALC_TYPE_FRAMES_AND_BYTES 2
+#define CALC_TYPE_COUNT 3
+#define CALC_TYPE_SUM 4
+#define CALC_TYPE_MIN 5
+#define CALC_TYPE_MAX 6
+#define CALC_TYPE_AVG 7
+#define CALC_TYPE_LOAD 8
typedef struct _io_stat_item_t {
io_stat_t *parent;
struct _io_stat_item_t *next;
struct _io_stat_item_t *prev;
- gint32 time; /* unit is ms since start of capture */
+ gint64 time; /* unit is us since start of capture */
int calc_type;
int hf_index;
- guint32 frames;
- guint32 num;
- guint32 counter;
+ guint64 frames;
+ guint64 num;
+ guint64 counter;
} io_stat_item_t;
+#define NANOSECS_PER_SEC 1000000000
static int
-iostat_packet(io_stat_item_t *mit, packet_info *pinfo, epan_dissect_t *edt _U_, void *dummy _U_)
+iostat_packet(void *arg, packet_info *pinfo, epan_dissect_t *edt, const void *dummy _U_)
{
+ io_stat_item_t *mit = arg;
io_stat_item_t *it;
- gint32 current_time;
+ gint64 current_time, ct;
GPtrArray *gp;
guint i;
- current_time=((pinfo->fd->rel_secs*1000)+(pinfo->fd->rel_usecs/1000));
+ current_time = (gint64)(pinfo->fd->rel_ts.secs*1000000) + (pinfo->fd->rel_ts.nsecs+500)/1000;
/* the prev item before the main one is always the last interval we saw packets for */
it=mit->prev;
}
/* we have moved into a new interval, we need to create a new struct */
- if(current_time>=(it->time+mit->parent->interval)){
+ ct = current_time;
+ while(ct >= (it->time + mit->parent->interval)){
it->next=g_malloc(sizeof(io_stat_item_t));
it->next->prev=it;
it->next->next=NULL;
it=it->next;
mit->prev=it;
- it->time=(current_time / mit->parent->interval) * mit->parent->interval;
- it->frames=0;
- it->counter=0;
- it->num=0;
+ it->time = it->prev->time + mit->parent->interval;
+ it->frames = 0;
+ it->counter = 0;
+ it->num = 0;
it->calc_type=it->prev->calc_type;
it->hf_index=it->prev->hf_index;
}
switch(it->calc_type){
case CALC_TYPE_BYTES:
+ case CALC_TYPE_FRAMES:
+ case CALC_TYPE_FRAMES_AND_BYTES:
it->counter+=pinfo->fd->pkt_len;
break;
case CALC_TYPE_COUNT:
case CALC_TYPE_SUM:
gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
if(gp){
+ guint64 val;
+ nstime_t *new_time;
+
for(i=0;i<gp->len;i++){
- it->counter+=fvalue_get_integer(((field_info *)gp->pdata[i])->value);
+ switch(proto_registrar_get_ftype(it->hf_index)){
+ case FT_UINT8:
+ case FT_UINT16:
+ case FT_UINT24:
+ case FT_UINT32:
+ it->counter+=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
+ break;
+ case FT_UINT64:
+ it->counter+=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
+ break;
+ case FT_INT8:
+ case FT_INT16:
+ case FT_INT24:
+ case FT_INT32:
+ it->counter+=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
+ break;
+ case FT_INT64:
+ it->counter+=(gint64)fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
+ break;
+ case FT_RELATIVE_TIME:
+ new_time = fvalue_get(&((field_info *)gp->pdata[i])->value);
+ val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
+ it->counter += val;
+ break;
+ }
}
}
break;
gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
if(gp){
int type;
- guint32 val;
+ guint64 val;
nstime_t *new_time;
type=proto_registrar_get_ftype(it->hf_index);
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
- val=fvalue_get_integer(((field_info *)gp->pdata[i])->value);
+ val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
if((it->frames==1)&&(i==0)){
it->counter=val;
} else if(val<it->counter){
it->counter=val;
- }
+ }
+ break;
+ case FT_UINT64:
+ val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
+ if((it->frames==1)&&(i==0)){
+ it->counter=val;
+ } else if(val<it->counter){
+ it->counter=val;
+ }
break;
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
- val=fvalue_get_integer(((field_info *)gp->pdata[i])->value);
+ val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
if((it->frames==1)&&(i==0)){
it->counter=val;
} else if((gint32)val<(gint32)(it->counter)){
it->counter=val;
- }
+ }
+ break;
+ case FT_INT64:
+ val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
+ if((it->frames==1)&&(i==0)){
+ it->counter=val;
+ } else if((gint64)val<(gint64)(it->counter)){
+ it->counter=val;
+ }
break;
case FT_RELATIVE_TIME:
- new_time=fvalue_get(((field_info *)gp->pdata[i])->value);
- val=new_time->secs*1000+new_time->nsecs/1000000;
+ new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
+ val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
if((it->frames==1)&&(i==0)){
it->counter=val;
} else if(val<it->counter){
it->counter=val;
- }
+ }
break;
}
}
gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
if(gp){
int type;
- guint32 val;
+ guint64 val;
nstime_t *new_time;
type=proto_registrar_get_ftype(it->hf_index);
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
- val=fvalue_get_integer(((field_info *)gp->pdata[i])->value);
+ val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
+ if((it->frames==1)&&(i==0)){
+ it->counter=val;
+ } else if(val>it->counter){
+ it->counter=val;
+ }
+ break;
+ case FT_UINT64:
+ val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
if((it->frames==1)&&(i==0)){
it->counter=val;
} else if(val>it->counter){
it->counter=val;
- }
+ }
break;
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
- val=fvalue_get_integer(((field_info *)gp->pdata[i])->value);
+ val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
if((it->frames==1)&&(i==0)){
it->counter=val;
} else if((gint32)val>(gint32)(it->counter)){
it->counter=val;
- }
+ }
+ break;
+ case FT_INT64:
+ val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
+ if((it->frames==1)&&(i==0)){
+ it->counter=val;
+ } else if((gint64)val>(gint64)(it->counter)){
+ it->counter=val;
+ }
break;
case FT_RELATIVE_TIME:
- new_time=fvalue_get(((field_info *)gp->pdata[i])->value);
- val=new_time->secs*1000+new_time->nsecs/1000000;
+ new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
+ val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
if((it->frames==1)&&(i==0)){
it->counter=val;
} else if(val>it->counter){
it->counter=val;
- }
+ }
break;
}
}
gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
if(gp){
int type;
- guint32 val;
+ guint64 val;
nstime_t *new_time;
type=proto_registrar_get_ftype(it->hf_index);
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
+ val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
+ it->counter+=val;
+ break;
+ case FT_UINT64:
+ case FT_INT64:
+ val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
+ it->counter+=val;
+ break;
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
- val=fvalue_get_integer(((field_info *)gp->pdata[i])->value);
+ val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
it->counter+=val;
break;
case FT_RELATIVE_TIME:
- new_time=fvalue_get(((field_info *)gp->pdata[i])->value);
- val=new_time->secs*1000+new_time->nsecs/1000000;
+ new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
+ val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
it->counter+=val;
break;
}
}
}
break;
+ case CALC_TYPE_LOAD:
+ gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
+ if(gp){
+ int type;
+
+ type=proto_registrar_get_ftype(it->hf_index);
+ if (type != FT_RELATIVE_TIME) {
+ fprintf(stderr,
+ "\ntshark: LOAD() is only supported for relative-time fiels such as smb.time\n"
+ );
+ exit(10);
+ }
+ for(i=0;i<gp->len;i++){
+ guint64 val;
+ int tival;
+ nstime_t *new_time;
+ io_stat_item_t *pit;
+
+ new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
+ val=(guint64)(new_time->secs)*1000000 + new_time->nsecs/1000;
+ tival = (int)(val % mit->parent->interval);
+ it->counter += tival;
+ val -= tival;
+ pit = it->prev;
+ while (val > 0) {
+ if (val < (guint64)mit->parent->interval) {
+ pit->counter += val;
+ val = 0;
+ break;
+ }
+
+ pit->counter += mit->parent->interval;
+ val -= mit->parent->interval;
+ pit = pit->prev;
+
+ }
+ }
+ }
+ break;
}
return TRUE;
}
static void
-iostat_draw(io_stat_item_t *mit)
+iostat_draw(void *arg)
{
+ io_stat_item_t *mit = arg;
io_stat_t *iot;
io_stat_item_t **items;
- guint32 *frames;
- guint32 *counters;
- guint32 *num;
- guint32 i,more_items;
- gint t;
+ guint64 *frames;
+ guint64 *counters;
+ guint64 *num;
+ guint32 i;
+ guint32 borderLen=68;
+ gboolean more_items;
+ gint64 t;
iot=mit->parent;
printf("\n");
- printf("===================================================================\n");
+
+ /* Display the table border */
+ for(i=0;i<iot->num_items;i++){
+ if(iot->items[i].calc_type==CALC_TYPE_FRAMES_AND_BYTES)
+ borderLen+=17;
+ }
+ if(iot->interval!=G_MAXINT32)
+ borderLen+=8;
+ if(iot->num_items>3)
+ borderLen+=(iot->num_items-3)*17;
+ for(i=0;i<borderLen;i++){
+ printf("=");
+ }
+ printf("\n");
+
+
printf("IO Statistics\n");
- printf("Interval: %d.%03d secs\n", iot->interval/1000, iot->interval%1000);
+ if(iot->interval!=G_MAXINT32)
+ printf("Interval: %3" G_GINT64_MODIFIER "u.%06" G_GINT64_MODIFIER "u secs\n",
+ iot->interval/1000000, iot->interval%1000000);
+
for(i=0;i<iot->num_items;i++){
- printf("Column #%d: %s\n",i,iot->filters[i]?iot->filters[i]:"");
+ printf("Column #%u: %s\n",i,iot->filters[i]?iot->filters[i]:"");
+ }
+ if(iot->interval==G_MAXINT32){
+ printf(" |");
+ } else {
+ printf(" |");
}
- printf(" ");
for(i=0;i<iot->num_items;i++){
- printf("| Column #%-2d ",i);
+ if(iot->items[i].calc_type==CALC_TYPE_FRAMES_AND_BYTES){
+ printf(" Column #%-2u |",i);
+ } else {
+ printf(" Column #%-2u |",i);
+ }
}
printf("\n");
- printf("Time ");
+
+ if(iot->interval==G_MAXINT32) {
+ printf("Time |");
+ } else {
+ printf("Time |");
+ }
for(i=0;i<iot->num_items;i++){
switch(iot->items[i].calc_type){
+ case CALC_TYPE_FRAMES:
+ printf(" FRAMES |");
+ break;
case CALC_TYPE_BYTES:
- printf("|frames| bytes ");
+ printf(" BYTES |");
+ break;
+ case CALC_TYPE_FRAMES_AND_BYTES:
+ printf(" Frames | Bytes |");
break;
case CALC_TYPE_COUNT:
- printf("| COUNT ");
+ printf(" COUNT |");
break;
case CALC_TYPE_SUM:
- printf("| SUM ");
+ printf(" SUM |");
break;
case CALC_TYPE_MIN:
- printf("| MIN ");
+ printf(" MIN |");
break;
case CALC_TYPE_MAX:
- printf("| MAX ");
+ printf(" MAX |");
break;
case CALC_TYPE_AVG:
- printf("| AVG ");
+ printf(" AVG |");
+ break;
+ case CALC_TYPE_LOAD:
+ printf(" LOAD |");
break;
}
}
printf("\n");
items=g_malloc(sizeof(io_stat_item_t *)*iot->num_items);
- frames=g_malloc(sizeof(guint32)*iot->num_items);
- counters=g_malloc(sizeof(guint32)*iot->num_items);
- num=g_malloc(sizeof(guint32)*iot->num_items);
+ frames=g_malloc(sizeof(guint64)*iot->num_items);
+ counters=g_malloc(sizeof(guint64)*iot->num_items);
+ num=g_malloc(sizeof(guint64)*iot->num_items);
/* preset all items at the first interval */
for(i=0;i<iot->num_items;i++){
items[i]=&iot->items[i];
/* loop the items until we run out of them all */
t=0;
do {
- more_items=0;
+ more_items=FALSE;
for(i=0;i<iot->num_items;i++){
frames[i]=0;
counters[i]=0;
}
if(items[i]){
- more_items=1;
+ more_items=TRUE;
}
}
if(more_items){
- printf("%03d.%03d-%03d.%03d ",
- t/1000,t%1000,
- (t+iot->interval)/1000,(t+iot->interval)%1000);
+ if(iot->interval==G_MAXINT32) {
+ printf("000.000- ");
+ } else {
+ printf("%04u.%06u-%04u.%06u ",
+ (int)(t/1000000),(int)(t%1000000),
+ (int)((t+iot->interval)/1000000),
+ (int)((t+iot->interval)%1000000));
+ }
for(i=0;i<iot->num_items;i++){
switch(iot->items[i].calc_type){
+ case CALC_TYPE_FRAMES:
+ printf(" %15" G_GINT64_MODIFIER "u ", frames[i]);
+ break;
case CALC_TYPE_BYTES:
- printf("%6d %9d ",frames[i],counters[i]);
+ printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
+ break;
+ case CALC_TYPE_FRAMES_AND_BYTES:
+ printf(" %15" G_GINT64_MODIFIER "u %15" G_GINT64_MODIFIER "u ", frames[i], counters[i]);
break;
case CALC_TYPE_COUNT:
- printf(" %8d ", counters[i]);
+ printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
break;
case CALC_TYPE_SUM:
- printf(" %8d ", counters[i]);
+ switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
+ case FT_RELATIVE_TIME:
+ counters[i] = (counters[i]+500)/1000;
+ printf(" %8u.%06u ",
+ (int)(counters[i]/1000000), (int)(counters[i]%1000000));
+ break;
+ default:
+ printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
+ break;
+ }
break;
case CALC_TYPE_MIN:
switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
- printf(" %8u ", counters[i]);
+ case FT_UINT64:
+ printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
break;
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
- printf(" %8d ", counters[i]);
+ case FT_INT64:
+ printf(" %15" G_GINT64_MODIFIER "d ", counters[i]);
break;
case FT_RELATIVE_TIME:
- printf(" %6d.%03d ", counters[i]/1000, counters[i]%1000);
+ counters[i]=(counters[i]+500)/1000;
+ printf(" %8u.%06u ",
+ (int)(counters[i]/1000000), (int)(counters[i]%1000000));
break;
}
break;
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
- printf(" %8u ", counters[i]);
+ case FT_UINT64:
+ printf(" %15u ", (int)(counters[i]));
break;
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
- printf(" %8d ", counters[i]);
+ case FT_INT64:
+ printf(" %15" G_GINT64_MODIFIER "d ", counters[i]);
break;
case FT_RELATIVE_TIME:
- printf(" %6d.%03d ", counters[i]/1000, counters[i]%1000);
+ counters[i]=(counters[i]+500)/1000;
+ printf(" %8u.%06u ",
+ (int)(counters[i]/1000000), (int)(counters[i]%1000000));
break;
}
break;
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
- printf(" %8u ", counters[i]/num[i]);
+ case FT_UINT64:
+ printf(" %15" G_GINT64_MODIFIER "u ", counters[i]/num[i]);
break;
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
- printf(" %8d ", counters[i]/num[i]);
+ case FT_INT64:
+ printf(" %15" G_GINT64_MODIFIER "d ", counters[i]/num[i]);
break;
case FT_RELATIVE_TIME:
- counters[i]/=num[i];
- printf(" %6d.%03d ", counters[i]/1000, counters[i]%1000);
+ counters[i]=((counters[i]/num[i])+500)/1000;
+ printf(" %8u.%06u ",
+ (int)(counters[i]/1000000), (int)(counters[i]%1000000));
+ break;
+ }
+ break;
+
+ case CALC_TYPE_LOAD:
+ switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
+ case FT_RELATIVE_TIME:
+ printf("%8u.%06u ",
+ (int)(counters[i]/iot->interval), (int)((counters[i]%iot->interval)*1000000/iot->interval));
break;
}
break;
t+=iot->interval;
} while(more_items);
- printf("===================================================================\n");
+ for(i=0;i<borderLen;i++){
+ printf("=");
+ }
+ printf("\n");
g_free(items);
g_free(frames);
}
-static int
-get_calc_field(char *filter, char **flt)
-{
- char field[256];
- int i;
- header_field_info *hfi;
-
- *flt="";
- for(i=0;filter[i];i++){
- if(i>=255){
- fprintf(stderr,"get_calc_field(): Too long field name: %s\n", filter);
- exit(10);
- }
- if(filter[i]==')'){
- break;
- }
- field[i]=filter[i];
- field[i+1]=0;
- }
- if(filter[i]==')'){
- *flt=&filter[i+1];
- }
-
- hfi=proto_registrar_get_byname(field);
- if(!hfi){
- fprintf(stderr, "get_calc_field(): No such field %s\n", field);
- exit(10);
- }
-
- return hfi->id;
-}
+typedef struct {
+ const char *func_name;
+ int calc_type;
+} calc_type_ent_t;
+
+static calc_type_ent_t calc_type_table[] = {
+ { "FRAMES", CALC_TYPE_FRAMES },
+ { "BYTES", CALC_TYPE_BYTES },
+ { "COUNT", CALC_TYPE_COUNT },
+ { "SUM", CALC_TYPE_SUM },
+ { "MIN", CALC_TYPE_MIN },
+ { "MAX", CALC_TYPE_MAX },
+ { "AVG", CALC_TYPE_AVG },
+ { "LOAD", CALC_TYPE_LOAD },
+ { NULL, 0 }
+};
static void
-register_io_tap(io_stat_t *io, int i, char *filter)
+register_io_tap(io_stat_t *io, int i, const char *filter)
{
GString *error_string;
- char *flt;
+ const char *flt;
+ int j;
+ size_t namelen;
+ const char *p, *parenp;
+ char *field;
+ header_field_info *hfi;
io->items[i].prev=&io->items[i];
io->items[i].next=NULL;
io->items[i].parent=io;
io->items[i].time=0;
- io->items[i].calc_type=CALC_TYPE_BYTES;
+ io->items[i].calc_type=CALC_TYPE_FRAMES_AND_BYTES;
io->items[i].frames=0;
io->items[i].counter=0;
io->items[i].num=0;
io->filters[i]=filter;
flt=filter;
- if(!filter){
- filter="";
- }
- if(!strncmp("COUNT(", filter, 6)){
- io->items[i].calc_type=CALC_TYPE_COUNT;
- io->items[i].hf_index=get_calc_field(filter+6, &flt);
- } else if (!strncmp("SUM(", filter, 4)){
- io->items[i].calc_type=CALC_TYPE_SUM;
- io->items[i].hf_index=get_calc_field(filter+4, &flt);
- switch(proto_registrar_get_nth(io->items[i].hf_index)->type){
- 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;
- default:
- fprintf(stderr, "register_io_tap(): Invalid field type. SUM(x) only supports 8,16,24 and 32 byte integer fields\n");
- exit(10);
+ field=NULL;
+ hfi=NULL;
+ for(j=0; calc_type_table[j].func_name; j++){
+ namelen=strlen(calc_type_table[j].func_name);
+ if(filter && strncmp(filter, calc_type_table[j].func_name, namelen) == 0) {
+ io->items[i].calc_type=calc_type_table[j].calc_type;
+ if(*(filter+namelen)=='(') {
+ p=filter+namelen+1;
+ parenp=strchr(p, ')');
+ if(!parenp){
+ fprintf(stderr, "\ntshark: Closing parenthesis missing from calculated expression.\n");
+ exit(10);
+ }
+
+
+ if(io->items[i].calc_type==CALC_TYPE_FRAMES || io->items[i].calc_type==CALC_TYPE_BYTES){
+ if(parenp!=p) {
+ fprintf(stderr, "\ntshark: %s does require or allow a field name within the parens.\n",
+ calc_type_table[j].func_name);
+ exit(10);
+ }
+ } else {
+ if(parenp==p) {
+ /* bail out if a field name was not specified */
+ fprintf(stderr, "\ntshark: You didn't specify a field name for %s(*).\n",
+ calc_type_table[j].func_name);
+ exit(10);
+ }
+ }
+
+ field=g_malloc(parenp-p+1);
+ memcpy(field, p, parenp-p);
+ field[parenp-p] = '\0';
+ flt=parenp + 1;
+ if (io->items[i].calc_type==CALC_TYPE_FRAMES || io->items[i].calc_type==CALC_TYPE_BYTES)
+ break;
+ hfi=proto_registrar_get_byname(field);
+ if(!hfi){
+ fprintf(stderr, "\ntshark: There is no field named '%s'.\n",
+ field);
+ g_free(field);
+ exit(10);
+ }
+
+ io->items[i].hf_index=hfi->id;
+ break;
+ }
+ } else {
+ if (io->items[i].calc_type==CALC_TYPE_FRAMES || io->items[i].calc_type==CALC_TYPE_BYTES)
+ flt="";
}
- } else if (!strncmp("MIN(", filter, 4)){
- io->items[i].calc_type=CALC_TYPE_MIN;
- io->items[i].hf_index=get_calc_field(filter+4, &flt);
- switch(proto_registrar_get_nth(io->items[i].hf_index)->type){
+ }
+ if(hfi && !(io->items[i].calc_type==CALC_TYPE_BYTES ||
+ io->items[i].calc_type==CALC_TYPE_FRAMES ||
+ io->items[i].calc_type==CALC_TYPE_FRAMES_AND_BYTES)){
+ /* check that the type is compatible */
+ switch(hfi->type){
case FT_UINT8:
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
+ case FT_UINT64:
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
- case FT_RELATIVE_TIME:
+ case FT_INT64:
+ /* these types support all calculations */
break;
- default:
- fprintf(stderr, "register_io_tap(): Invalid field type. MIN(x) only supports 8,16,24 and 32 byte integer fields and relative time fields\n");
- exit(10);
- }
- } else if (!strncmp("MAX(", filter, 4)){
- io->items[i].calc_type=CALC_TYPE_MAX;
- io->items[i].hf_index=get_calc_field(filter+4, &flt);
- switch(proto_registrar_get_nth(io->items[i].hf_index)->type){
- case FT_UINT8:
- case FT_UINT16:
- case FT_UINT24:
- case FT_UINT32:
- case FT_INT8:
- case FT_INT16:
- case FT_INT24:
- case FT_INT32:
case FT_RELATIVE_TIME:
+ /* this type only supports SUM, COUNT, MAX, MIN, AVG */
+ switch(io->items[i].calc_type){
+ case CALC_TYPE_SUM:
+ case CALC_TYPE_COUNT:
+ case CALC_TYPE_MAX:
+ case CALC_TYPE_MIN:
+ case CALC_TYPE_AVG:
+ case CALC_TYPE_LOAD:
+ break;
+ default:
+ fprintf(stderr,
+ "\ntshark: %s is a relative-time field, so %s(*) calculations are not supported on it.",
+ field,
+ calc_type_table[j].func_name);
+ exit(10);
+ }
break;
default:
- fprintf(stderr, "register_io_tap(): Invalid field type. MAX(x) only supports 8,16,24 and 32 byte integer fields and relative time fields\n");
- exit(10);
- }
- } else if (!strncmp("AVG(", filter, 4)){
- io->items[i].calc_type=CALC_TYPE_AVG;
- io->items[i].hf_index=get_calc_field(filter+4, &flt);
- switch(proto_registrar_get_nth(io->items[i].hf_index)->type){
- case FT_UINT8:
- case FT_UINT16:
- case FT_UINT24:
- case FT_UINT32:
- case FT_INT8:
- case FT_INT16:
- case FT_INT24:
- case FT_INT32:
- case FT_RELATIVE_TIME:
+ /*
+ * XXX - support all operations on floating-point
+ * numbers?
+ */
+ if(io->items[i].calc_type!=CALC_TYPE_COUNT){
+ fprintf(stderr,
+ "\ntshark: %s doesn't have integral values, so %s(*) calculations are not supported on it.\n",
+ field,
+ calc_type_table[j].func_name);
+ exit(10);
+ }
break;
- default:
- fprintf(stderr, "register_io_tap(): Invalid field type. AVG(x) only supports 8,16,24 and 32 byte integer fields and relative time fields\n");
- exit(10);
}
+ g_free(field);
}
-/*
-CALC_TYPE_SUM 2
-CALC_TYPE_MIN 3
-CALC_TYPE_MAX 4
-CALC_TYPE_AVG 5
-*/
-
- error_string=register_tap_listener("frame", &io->items[i], flt, NULL, (void*)iostat_packet, i?NULL:(void*)iostat_draw);
+ error_string=register_tap_listener("frame", &io->items[i], flt, TL_REQUIRES_PROTO_TREE, NULL, iostat_packet, i?NULL:iostat_draw);
if(error_string){
g_free(io->items);
g_free(io);
- fprintf(stderr, "tethereal: Couldn't register io,stat tap: %s\n",
+ fprintf(stderr, "\ntshark: Couldn't register io,stat tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
}
}
-void
-iostat_init(char *optarg)
+static void
+iostat_init(const char *optarg, void* userdata _U_)
{
- float interval_float;
- gint32 interval;
- int pos=0;
+ gdouble interval_float;
+ gint64 interval;
+ int idx=0;
io_stat_t *io;
- char *filter=NULL;
-
- if(sscanf(optarg,"io,stat,%f,%n",&interval_float,&pos)==1){
- if(pos){
- filter=optarg+pos;
+ const char *filter=NULL;
+
+ if(sscanf(optarg,"io,stat,%lf,%n",&interval_float,&idx)==1){
+ if(idx){
+ if(*(optarg+idx)==',')
+ filter=optarg+idx+1;
+ else
+ filter=optarg+idx;
} else {
filter=NULL;
}
} else {
- fprintf(stderr, "tethereal: invalid \"-z io,stat,<interval>[,<filter>]\" argument\n");
+ fprintf(stderr, "\ntshark: invalid \"-z io,stat,<interval>[,<filter>]\" argument\n");
exit(1);
}
+ /* if interval is 0, calculate statistics over the whole file
+ * by setting the interval to G_MAXINT32
+ */
+ if(interval_float==0) {
+ interval=G_MAXINT32;
+ } else {
+ /* make interval be number of us rounded to the nearest integer*/
+ interval=(gint64)(interval_float*1000000.0+0.5);
+ }
- /* make interval be number of ms */
- interval=(gint32)(interval_float*1000.0+0.9);
if(interval<1){
- fprintf(stderr, "tethereal:iostat_init() interval must be >=0.001 seconds\n");
+ fprintf(stderr,
+ "\ntshark: \"-z\" interval must be >=0.000001 seconds or \"0\" for the entire capture duration.\n");
exit(10);
}
-
+
io=g_malloc(sizeof(io_stat_t));
io->interval=interval;
if((!filter)||(filter[0]==0)){
register_io_tap(io, 0, NULL);
} else {
- char *str,*pos,*tmp;
+ const char *str,*pos;
+ char *tmp;
int i;
/* find how many ',' separated filters we have */
str=filter;
io->items=g_malloc(sizeof(io_stat_item_t)*io->num_items);
io->filters=g_malloc(sizeof(char *)*io->num_items);
- /* for each filter, register a tap listener */
+ /* for each filter, register a tap listener */
i=0;
str=filter;
do{
if(pos==str){
register_io_tap(io, i, NULL);
} else if(pos==NULL) {
- tmp=g_malloc(strlen(str)+1);
- strcpy(tmp,str);
+ tmp=g_strdup(str);
register_io_tap(io, i, tmp);
} else {
tmp=g_malloc((pos-str)+1);
- strncpy(tmp,str,(pos-str));
- tmp[pos-str]=0;
+ g_strlcpy(tmp,str,(pos-str)+1);
register_io_tap(io, i, tmp);
}
str=pos+1;
- i++;
+ i++;
} while(pos);
- }
+ }
}
void
register_tap_listener_iostat(void)
{
- register_ethereal_tap("io,stat,", iostat_init);
+ register_stat_cmd_arg("io,stat,", iostat_init, NULL);
}
-
git.samba.org / obnox / wireshark / wip.git / blobdiff