tap-iostat.c

   1 /* tap-iostat.c
   2  * iostat   2002 Ronnie Sahlberg
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <stdio.h>
  30
  31 #ifdef HAVE_SYS_TYPES_H
  32 # include <sys/types.h>
  33 #endif
  34
  35 #include <string.h>
  36 #include "epan/epan_dissect.h"
  37 #include "epan/packet_info.h"
  38 #include <epan/tap.h>
  39 #include <epan/stat_cmd_args.h>
  40 #include <epan/strutil.h>
  41
  42
  43 typedef struct _io_stat_t {
  44         gint64 interval;        /* unit is us */
  45         guint32 num_items;
  46         struct _io_stat_item_t *items;
  47         const char **filters;
  48 } io_stat_t;
  49
  50 #define CALC_TYPE_FRAMES 0
  51 #define CALC_TYPE_BYTES  1
  52 #define CALC_TYPE_FRAMES_AND_BYTES       2
  53 #define CALC_TYPE_COUNT  3
  54 #define CALC_TYPE_SUM    4
  55 #define CALC_TYPE_MIN    5
  56 #define CALC_TYPE_MAX    6
  57 #define CALC_TYPE_AVG    7
  58 #define CALC_TYPE_LOAD   8
  59
  60 typedef struct _io_stat_item_t {
  61         io_stat_t *parent;
  62         struct _io_stat_item_t *next;
  63         struct _io_stat_item_t *prev;
  64         gint64 time;            /* unit is us since start of capture */
  65         int calc_type;
  66         int hf_index;
  67         guint64 frames;
  68         guint64 num;
  69         guint64 counter;
  70         gfloat float_counter;
  71         gdouble double_counter;
  72 } io_stat_item_t;
  73
  74 #define NANOSECS_PER_SEC 1000000000
  75
  76 static int
  77 iostat_packet(void *arg, packet_info *pinfo, epan_dissect_t *edt, const void *dummy _U_)
  78 {
  79         io_stat_item_t *mit = arg;
  80         io_stat_item_t *it;
  81         gint64 current_time, ct;
  82         GPtrArray *gp;
  83         guint i;
  84
  85         current_time = (gint64)(pinfo->fd->rel_ts.secs*1000000) + (pinfo->fd->rel_ts.nsecs+500)/1000;
  86
  87         /* the prev item before the main one is always the last interval we saw packets for */
  88         it=mit->prev;
  89
  90         /* XXX for the time being, just ignore all frames that are in the past.
  91            should be fixed in the future but hopefully it is uncommon */
  92         if(current_time<it->time){
  93                 return FALSE;
  94         }
  95
  96         /* we have moved into a new interval, we need to create a new struct */
  97         ct = current_time;
  98         while(ct >= (it->time + mit->parent->interval)){
  99                 it->next=g_malloc(sizeof(io_stat_item_t));
 100                 it->next->prev=it;
 101                 it->next->next=NULL;
 102                 it=it->next;
 103                 mit->prev=it;
 104
 105                 it->time    = it->prev->time + mit->parent->interval;
 106                 it->frames  = 0;
 107                 it->counter = 0;
 108                 it->float_counter = 0;
 109                 it->double_counter = 0;
 110                 it->num     = 0;
 111                 it->calc_type=it->prev->calc_type;
 112                 it->hf_index=it->prev->hf_index;
 113         }
 114
 115         /* it will now give us the current structure to use to store the data in */
 116         it->frames++;
 117
 118         switch(it->calc_type){
 119         case CALC_TYPE_BYTES:
 120         case CALC_TYPE_FRAMES:
 121         case CALC_TYPE_FRAMES_AND_BYTES:
 122                 it->counter+=pinfo->fd->pkt_len;
 123                 break;
 124         case CALC_TYPE_COUNT:
 125                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
 126                 if(gp){
 127                         it->counter+=gp->len;
 128                 }
 129                 break;
 130         case CALC_TYPE_SUM:
 131                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
 132                 if(gp){
 133                         guint64 val;
 134                         nstime_t *new_time;
 135
 136                         for(i=0;i<gp->len;i++){
 137                                 switch(proto_registrar_get_ftype(it->hf_index)){
 138                                 case FT_UINT8:
 139                                 case FT_UINT16:
 140                                 case FT_UINT24:
 141                                 case FT_UINT32:
 142                                         it->counter+=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
 143                                         break;
 144                                 case FT_UINT64:
 145                                         it->counter+=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
 146                                         break;
 147                                 case FT_INT8:
 148                                 case FT_INT16:
 149                                 case FT_INT24:
 150                                 case FT_INT32:
 151                                         it->counter+=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
 152                                         break;
 153                                 case FT_INT64:
 154                                         it->counter+=(gint64)fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
 155                                         break;
 156                                 case FT_FLOAT:
 157                                         it->float_counter+=(gfloat)fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 158                                         break;
 159                                 case FT_DOUBLE:
 160                                         it->double_counter+=fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 161                                         break;
 162                                 case FT_RELATIVE_TIME:
 163                                         new_time = fvalue_get(&((field_info *)gp->pdata[i])->value);
 164                                         val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
 165                                         it->counter += val;
 166                                         break;
 167                                 }
 168                         }
 169                 }
 170                 break;
 171         case CALC_TYPE_MIN:
 172                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
 173                 if(gp){
 174                         int type;
 175                         guint64 val;
 176                         gfloat float_val;
 177                         gdouble double_val;
 178                         nstime_t *new_time;
 179
 180                         type=proto_registrar_get_ftype(it->hf_index);
 181                         for(i=0;i<gp->len;i++){
 182                                 switch(type){
 183                                 case FT_UINT8:
 184                                 case FT_UINT16:
 185                                 case FT_UINT24:
 186                                 case FT_UINT32:
 187                                         val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
 188                                         if((it->frames==1)&&(i==0)){
 189                                                 it->counter=val;
 190                                         } else if(val<it->counter){
 191                                                 it->counter=val;
 192                                         }
 193                                         break;
 194                                 case FT_UINT64:
 195                                         val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
 196                                         if((it->frames==1)&&(i==0)){
 197                                                 it->counter=val;
 198                                         } else if(val<it->counter){
 199                                                 it->counter=val;
 200                                         }
 201                                         break;
 202                                 case FT_INT8:
 203                                 case FT_INT16:
 204                                 case FT_INT24:
 205                                 case FT_INT32:
 206                                         val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
 207                                         if((it->frames==1)&&(i==0)){
 208                                                 it->counter=val;
 209                                         } else if((gint32)val<(gint32)(it->counter)){
 210                                                 it->counter=val;
 211                                         }
 212                                         break;
 213                                 case FT_INT64:
 214                                         val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
 215                                         if((it->frames==1)&&(i==0)){
 216                                                 it->counter=val;
 217                                         } else if((gint64)val<(gint64)(it->counter)){
 218                                                 it->counter=val;
 219                                         }
 220                                         break;
 221                                 case FT_FLOAT:
 222                                         float_val=(gfloat)fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 223                                         if((it->frames==1)&&(i==0)){
 224                                                 it->float_counter=float_val;
 225                                         } else if(float_val<it->float_counter){
 226                                                 it->float_counter=float_val;
 227                                         }
 228                                         break;
 229                                 case FT_DOUBLE:
 230                                         double_val=fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 231                                         if((it->frames==1)&&(i==0)){
 232                                                 it->double_counter=double_val;
 233                                         } else if(double_val<it->double_counter){
 234                                                 it->double_counter=double_val;
 235                                         }
 236                                         break;
 237                                 case FT_RELATIVE_TIME:
 238                                         new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
 239                                         val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
 240                                         if((it->frames==1)&&(i==0)){
 241                                                 it->counter=val;
 242                                         } else if(val<it->counter){
 243                                                 it->counter=val;
 244                                         }
 245                                         break;
 246                                 }
 247                         }
 248                 }
 249                 break;
 250         case CALC_TYPE_MAX:
 251                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
 252                 if(gp){
 253                         int type;
 254                         guint64 val;
 255                         gfloat float_val;
 256                         gdouble double_val;
 257                         nstime_t *new_time;
 258
 259                         type=proto_registrar_get_ftype(it->hf_index);
 260                         for(i=0;i<gp->len;i++){
 261                                 switch(type){
 262                                 case FT_UINT8:
 263                                 case FT_UINT16:
 264                                 case FT_UINT24:
 265                                 case FT_UINT32:
 266                                         val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
 267                                         if((it->frames==1)&&(i==0)){
 268                                                 it->counter=val;
 269                                         } else if(val>it->counter){
 270                                                 it->counter=val;
 271                                         }
 272                                         break;
 273                                 case FT_UINT64:
 274                                         val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
 275                                         if((it->frames==1)&&(i==0)){
 276                                                 it->counter=val;
 277                                         } else if(val>it->counter){
 278                                                 it->counter=val;
 279                                         }
 280                                         break;
 281                                 case FT_INT8:
 282                                 case FT_INT16:
 283                                 case FT_INT24:
 284                                 case FT_INT32:
 285                                         val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
 286                                         if((it->frames==1)&&(i==0)){
 287                                                 it->counter=val;
 288                                         } else if((gint32)val>(gint32)(it->counter)){
 289                                                 it->counter=val;
 290                                         }
 291                                         break;
 292                                 case FT_INT64:
 293                                         val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
 294                                         if((it->frames==1)&&(i==0)){
 295                                                 it->counter=val;
 296                                         } else if((gint64)val>(gint64)(it->counter)){
 297                                                 it->counter=val;
 298                                         }
 299                                         break;
 300                                 case FT_FLOAT:
 301                                         float_val=(gfloat)fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 302                                         if((it->frames==1)&&(i==0)){
 303                                                 it->float_counter=float_val;
 304                                         } else if(float_val>it->float_counter){
 305                                                 it->float_counter=float_val;
 306                                         }
 307                                         break;
 308                                 case FT_DOUBLE:
 309                                         double_val=fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 310                                         if((it->frames==1)&&(i==0)){
 311                                                 it->double_counter=double_val;
 312                                         } else if(double_val>it->double_counter){
 313                                                 it->double_counter=double_val;
 314                                         }
 315                                         break;
 316                                 case FT_RELATIVE_TIME:
 317                                         new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
 318                                         val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
 319                                         if((it->frames==1)&&(i==0)){
 320                                                 it->counter=val;
 321                                         } else if(val>it->counter){
 322                                                 it->counter=val;
 323                                         }
 324                                         break;
 325                                 }
 326                         }
 327                 }
 328                 break;
 329         case CALC_TYPE_AVG:
 330                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
 331                 if(gp){
 332                         int type;
 333                         guint64 val;
 334                         nstime_t *new_time;
 335
 336                         type=proto_registrar_get_ftype(it->hf_index);
 337                         for(i=0;i<gp->len;i++){
 338                                 it->num++;
 339                                 switch(type){
 340                                 case FT_UINT8:
 341                                 case FT_UINT16:
 342                                 case FT_UINT24:
 343                                 case FT_UINT32:
 344                                         val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
 345                                         it->counter+=val;
 346                                         break;
 347                                 case FT_UINT64:
 348                                 case FT_INT64:
 349                                         val=fvalue_get_integer64(&((field_info *)gp->pdata[i])->value);
 350                                         it->counter+=val;
 351                                         break;
 352                                 case FT_INT8:
 353                                 case FT_INT16:
 354                                 case FT_INT24:
 355                                 case FT_INT32:
 356                                         val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
 357                                         it->counter+=val;
 358                                         break;
 359                                 case FT_FLOAT:
 360                                         it->float_counter+=(gfloat)fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 361                                         break;
 362                                 case FT_DOUBLE:
 363                                         it->double_counter+=fvalue_get_floating(&((field_info *)gp->pdata[i])->value);
 364                                         break;
 365                                 case FT_RELATIVE_TIME:
 366                                         new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
 367                                         val=(guint64)(new_time->secs) * NANOSECS_PER_SEC + new_time->nsecs;
 368                                         it->counter+=val;
 369                                         break;
 370                                 }
 371                         }
 372                 }
 373                 break;
 374         case CALC_TYPE_LOAD:
 375                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
 376                 if(gp){
 377                         int type;
 378
 379                         type=proto_registrar_get_ftype(it->hf_index);
 380                         if (type != FT_RELATIVE_TIME) {
 381                                 fprintf(stderr,
 382                                         "\ntshark: LOAD() is only supported for relative-time fiels such as smb.time\n"
 383                                         );
 384                                 exit(10);
 385                         }
 386                         for(i=0;i<gp->len;i++){
 387                                 guint64 val;
 388                                 int tival;
 389                                 nstime_t *new_time;
 390                                 io_stat_item_t *pit;
 391
 392                                 new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
 393                                 val=(guint64)(new_time->secs)*1000000 + new_time->nsecs/1000;
 394                                 tival = (int)(val % mit->parent->interval);
 395                                 it->counter += tival;
 396                                 val -= tival;
 397                                 pit = it->prev;
 398                                 while (val > 0) {
 399                                         if (val < (guint64)mit->parent->interval) {
 400                                                 pit->counter += val;
 401                                                 val = 0;
 402                                                 break;
 403                                         }
 404
 405                                         pit->counter += mit->parent->interval;
 406                                         val -= mit->parent->interval;
 407                                         pit = pit->prev;
 408
 409                                 }
 410                         }
 411                 }
 412                 break;
 413         }
 414
 415         return TRUE;
 416 }
 417
 418 static void
 419 iostat_draw(void *arg)
 420 {
 421         io_stat_item_t *mit = arg;
 422         io_stat_t *iot;
 423         io_stat_item_t **items;
 424         guint64 *frames;
 425         guint64 *counters;
 426         gfloat *float_counters;
 427         gdouble *double_counters;
 428         guint64 *num;
 429         guint32 i;
 430         guint32 borderLen=68;
 431         gboolean more_items;
 432         gint64 t;
 433
 434         iot=mit->parent;
 435
 436         printf("\n");
 437
 438         /* Display the table border */
 439         for(i=0;i<iot->num_items;i++){
 440                 if(iot->items[i].calc_type==CALC_TYPE_FRAMES_AND_BYTES)
 441                         borderLen+=17;
 442         }
 443         if(iot->interval!=G_MAXINT32)
 444                 borderLen+=8;
 445         if(iot->num_items>3)
 446                 borderLen+=(iot->num_items-3)*17;
 447         for(i=0;i<borderLen;i++){
 448                 printf("=");
 449         }
 450         printf("\n");
 451
 452
 453         printf("IO Statistics\n");
 454         if(iot->interval!=G_MAXINT32)
 455                 printf("Interval: %3" G_GINT64_MODIFIER "u.%06" G_GINT64_MODIFIER "u secs\n",
 456                                 iot->interval/1000000, iot->interval%1000000);
 457
 458         for(i=0;i<iot->num_items;i++){
 459                 printf("Column #%u: %s\n",i,iot->filters[i]?iot->filters[i]:"");
 460         }
 461         if(iot->interval==G_MAXINT32){
 462                 printf("                |");
 463         } else {
 464                 printf("                        |");
 465         }
 466         for(i=0;i<iot->num_items;i++){
 467                 if(iot->items[i].calc_type==CALC_TYPE_FRAMES_AND_BYTES){
 468                         printf("            Column #%-2u           |",i);
 469                 } else {
 470                         printf("    Column #%-2u  |",i);
 471                 }
 472         }
 473         printf("\n");
 474
 475         if(iot->interval==G_MAXINT32) {
 476                 printf("Time            |");
 477         } else {
 478                 printf("Time                    |");
 479         }
 480         for(i=0;i<iot->num_items;i++){
 481                 switch(iot->items[i].calc_type){
 482                 case CALC_TYPE_FRAMES:
 483                         printf("     FRAMES     |");
 484                         break;
 485                 case CALC_TYPE_BYTES:
 486                         printf("     BYTES      |");
 487                         break;
 488                 case CALC_TYPE_FRAMES_AND_BYTES:
 489                         printf("     Frames     |      Bytes     |");
 490                         break;
 491                 case CALC_TYPE_COUNT:
 492                         printf("      COUNT     |");
 493                         break;
 494                 case CALC_TYPE_SUM:
 495                         printf("       SUM      |");
 496                         break;
 497                 case CALC_TYPE_MIN:
 498                         printf("       MIN      |");
 499                         break;
 500                 case CALC_TYPE_MAX:
 501                         printf("       MAX      |");
 502                         break;
 503                 case CALC_TYPE_AVG:
 504                         printf("       AVG      |");
 505                         break;
 506                 case CALC_TYPE_LOAD:
 507                         printf("       LOAD     |");
 508                         break;
 509                 }
 510         }
 511         printf("\n");
 512
 513         items=g_malloc(sizeof(io_stat_item_t *)*iot->num_items);
 514         frames=g_malloc(sizeof(guint64)*iot->num_items);
 515         counters=g_malloc(sizeof(guint64)*iot->num_items);
 516         float_counters=g_malloc(sizeof(gfloat)*iot->num_items);
 517         double_counters=g_malloc(sizeof(gdouble)*iot->num_items);
 518         num=g_malloc(sizeof(guint64)*iot->num_items);
 519         /* preset all items at the first interval */
 520         for(i=0;i<iot->num_items;i++){
 521                 items[i]=&iot->items[i];
 522         }
 523
 524         /* loop the items until we run out of them all */
 525         t=0;
 526         do {
 527                 more_items=FALSE;
 528                 for(i=0;i<iot->num_items;i++){
 529                         frames[i]=0;
 530                         counters[i]=0;
 531                         float_counters[i]=0;
 532                         double_counters[i]=0;
 533                         num[i]=0;
 534                 }
 535                 for(i=0;i<iot->num_items;i++){
 536                         if(items[i] && (t>=(items[i]->time+iot->interval))){
 537                                 items[i]=items[i]->next;
 538                         }
 539
 540                         if(items[i] && (t<(items[i]->time+iot->interval)) && (t>=items[i]->time) ){
 541                                 frames[i]=items[i]->frames;
 542                                 counters[i]=items[i]->counter;
 543                                 float_counters[i]=items[i]->float_counter;
 544                                 double_counters[i]=items[i]->double_counter;
 545                                 num[i]=items[i]->num;
 546                         }
 547
 548                         if(items[i]){
 549                                 more_items=TRUE;
 550                         }
 551                 }
 552
 553                 if(more_items){
 554                         if(iot->interval==G_MAXINT32) {
 555                                 printf("000.000-         ");
 556                         } else {
 557                                 printf("%04u.%06u-%04u.%06u  ",
 558                                                 (int)(t/1000000),(int)(t%1000000),
 559                                                 (int)((t+iot->interval)/1000000),
 560                                                 (int)((t+iot->interval)%1000000));
 561                         }
 562                         for(i=0;i<iot->num_items;i++){
 563                                 switch(iot->items[i].calc_type){
 564                                 case CALC_TYPE_FRAMES:
 565                                         printf(" %15" G_GINT64_MODIFIER "u ", frames[i]);
 566                                         break;
 567                                 case CALC_TYPE_BYTES:
 568                                         printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
 569                                         break;
 570                                 case CALC_TYPE_FRAMES_AND_BYTES:
 571                                         printf(" %15" G_GINT64_MODIFIER "u  %15" G_GINT64_MODIFIER "u ", frames[i], counters[i]);
 572                                         break;
 573                                 case CALC_TYPE_COUNT:
 574                                         printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
 575                                         break;
 576                                 case CALC_TYPE_SUM:
 577                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
 578                                         case FT_UINT8:
 579                                         case FT_UINT16:
 580                                         case FT_UINT24:
 581                                         case FT_UINT32:
 582                                         case FT_UINT64:
 583                                         case FT_INT8:
 584                                         case FT_INT16:
 585                                         case FT_INT24:
 586                                         case FT_INT32:
 587                                         case FT_INT64:
 588                                                 printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
 589                                                 break;
 590                                         case FT_FLOAT:
 591                                                 printf(" %f ", float_counters[i]);
 592                                                 break;
 593                                         case FT_DOUBLE:
 594                                                 printf(" %f ", double_counters[i]);
 595                                                 break;
 596                                         case FT_RELATIVE_TIME:
 597                                                 counters[i] = (counters[i]+500)/1000;
 598                                                 printf(" %8u.%06u ",
 599                                                                 (int)(counters[i]/1000000), (int)(counters[i]%1000000));
 600                                                 break;
 601                                         }
 602                                         break;
 603                                 case CALC_TYPE_MIN:
 604                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
 605                                         case FT_UINT8:
 606                                         case FT_UINT16:
 607                                         case FT_UINT24:
 608                                         case FT_UINT32:
 609                                         case FT_UINT64:
 610                                                 printf(" %15" G_GINT64_MODIFIER "u ", counters[i]);
 611                                                 break;
 612                                         case FT_INT8:
 613                                         case FT_INT16:
 614                                         case FT_INT24:
 615                                         case FT_INT32:
 616                                         case FT_INT64:
 617                                                 printf(" %15" G_GINT64_MODIFIER "d ", counters[i]);
 618                                                 break;
 619                                         case FT_FLOAT:
 620                                                 printf(" %f ", float_counters[i]);
 621                                                 break;
 622                                         case FT_DOUBLE:
 623                                                 printf(" %f ", double_counters[i]);
 624                                                 break;
 625                                         case FT_RELATIVE_TIME:
 626                                                 counters[i]=(counters[i]+500)/1000;
 627                                                 printf(" %8u.%06u ",
 628                                                                 (int)(counters[i]/1000000), (int)(counters[i]%1000000));
 629                                                 break;
 630                                         }
 631                                         break;
 632                                 case CALC_TYPE_MAX:
 633                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
 634                                         case FT_UINT8:
 635                                         case FT_UINT16:
 636                                         case FT_UINT24:
 637                                         case FT_UINT32:
 638                                         case FT_UINT64:
 639                                                 printf(" %15u ", (int)(counters[i]));
 640                                                 break;
 641                                         case FT_INT8:
 642                                         case FT_INT16:
 643                                         case FT_INT24:
 644                                         case FT_INT32:
 645                                         case FT_INT64:
 646                                                 printf(" %15" G_GINT64_MODIFIER "d ", counters[i]);
 647                                                 break;
 648                                         case FT_FLOAT:
 649                                                 printf(" %f ", float_counters[i]);
 650                                                 break;
 651                                         case FT_DOUBLE:
 652                                                 printf(" %f ", double_counters[i]);
 653                                                 break;
 654                                         case FT_RELATIVE_TIME:
 655                                                 counters[i]=(counters[i]+500)/1000;
 656                                                 printf(" %8u.%06u ",
 657                                                                 (int)(counters[i]/1000000), (int)(counters[i]%1000000));
 658                                                 break;
 659                                         }
 660                                         break;
 661                                 case CALC_TYPE_AVG:
 662                                         if(num[i]==0){
 663                                                 num[i]=1;
 664                                         }
 665                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
 666                                         case FT_UINT8:
 667                                         case FT_UINT16:
 668                                         case FT_UINT24:
 669                                         case FT_UINT32:
 670                                         case FT_UINT64:
 671                                                 printf(" %15" G_GINT64_MODIFIER "u ", counters[i]/num[i]);
 672                                                 break;
 673                                         case FT_INT8:
 674                                         case FT_INT16:
 675                                         case FT_INT24:
 676                                         case FT_INT32:
 677                                         case FT_INT64:
 678                                                 printf(" %15" G_GINT64_MODIFIER "d ", counters[i]/num[i]);
 679                                                 break;
 680                                         case FT_FLOAT:
 681                                                 printf(" %f ", float_counters[i]/num[i]);
 682                                                 break;
 683                                         case FT_DOUBLE:
 684                                                 printf(" %f ", double_counters[i]/num[i]);
 685                                                 break;
 686                                         case FT_RELATIVE_TIME:
 687                                                 counters[i]=((counters[i]/num[i])+500)/1000;
 688                                                 printf(" %8u.%06u ",
 689                                                                 (int)(counters[i]/1000000), (int)(counters[i]%1000000));
 690                                                 break;
 691                                         }
 692                                         break;
 693
 694                                 case CALC_TYPE_LOAD:
 695                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
 696                                         case FT_RELATIVE_TIME:
 697                                                 printf("%8u.%06u ",
 698                                                                 (int)(counters[i]/iot->interval), (int)((counters[i]%iot->interval)*1000000/iot->interval));
 699                                                 break;
 700                                         }
 701                                         break;
 702
 703                                 }
 704                         }
 705                         printf("\n");
 706                 }
 707
 708                 t+=iot->interval;
 709         } while(more_items);
 710
 711         for(i=0;i<borderLen;i++){
 712                 printf("=");
 713         }
 714         printf("\n");
 715
 716         g_free(items);
 717         g_free(frames);
 718         g_free(counters);
 719         g_free(float_counters);
 720         g_free(double_counters);
 721         g_free(num);
 722 }
 723
 724
 725 typedef struct {
 726         const char *func_name;
 727         int calc_type;
 728 } calc_type_ent_t;
 729
 730 static calc_type_ent_t calc_type_table[] = {
 731         { "FRAMES", CALC_TYPE_FRAMES },
 732         { "BYTES", CALC_TYPE_BYTES },
 733         { "COUNT", CALC_TYPE_COUNT },
 734         { "SUM", CALC_TYPE_SUM },
 735         { "MIN", CALC_TYPE_MIN },
 736         { "MAX", CALC_TYPE_MAX },
 737         { "AVG", CALC_TYPE_AVG },
 738         { "LOAD", CALC_TYPE_LOAD },
 739         { NULL, 0 }
 740 };
 741
 742 static void
 743 register_io_tap(io_stat_t *io, int i, const char *filter)
 744 {
 745         GString *error_string;
 746         const char *flt;
 747         int j;
 748         size_t namelen;
 749         const char *p, *parenp;
 750         char *field;
 751         header_field_info *hfi;
 752
 753         io->items[i].prev=&io->items[i];
 754         io->items[i].next=NULL;
 755         io->items[i].parent=io;
 756         io->items[i].time=0;
 757         io->items[i].calc_type=CALC_TYPE_FRAMES_AND_BYTES;
 758         io->items[i].frames=0;
 759         io->items[i].counter=0;
 760         io->items[i].num=0;
 761         io->filters[i]=filter;
 762         flt=filter;
 763
 764         field=NULL;
 765         hfi=NULL;
 766         for(j=0; calc_type_table[j].func_name; j++){
 767                 namelen=strlen(calc_type_table[j].func_name);
 768                 if(filter && strncmp(filter, calc_type_table[j].func_name, namelen) == 0) {
 769                         io->items[i].calc_type=calc_type_table[j].calc_type;
 770                         if(*(filter+namelen)=='(') {
 771                                 p=filter+namelen+1;
 772                                 parenp=strchr(p, ')');
 773                                 if(!parenp){
 774                                         fprintf(stderr, "\ntshark: Closing parenthesis missing from calculated expression.\n");
 775                                         exit(10);
 776                                 }
 777
 778
 779                                 if(io->items[i].calc_type==CALC_TYPE_FRAMES || io->items[i].calc_type==CALC_TYPE_BYTES){
 780                                         if(parenp!=p) {
 781                                                 fprintf(stderr, "\ntshark: %s does require or allow a field name within the parens.\n",
 782                                                         calc_type_table[j].func_name);
 783                                                 exit(10);
 784                                         }
 785                                 } else {
 786                                         if(parenp==p) {
 787                                                         /* bail out if a field name was not specified */
 788                                                         fprintf(stderr, "\ntshark: You didn't specify a field name for %s(*).\n",
 789                                                                 calc_type_table[j].func_name);
 790                                                         exit(10);
 791                                         }
 792                                 }
 793
 794                                 field=g_malloc(parenp-p+1);
 795                                 memcpy(field, p, parenp-p);
 796                                 field[parenp-p] = '\0';
 797                                 flt=parenp + 1;
 798                                 if (io->items[i].calc_type==CALC_TYPE_FRAMES || io->items[i].calc_type==CALC_TYPE_BYTES)
 799                                         break;
 800                                 hfi=proto_registrar_get_byname(field);
 801                                 if(!hfi){
 802                                         fprintf(stderr, "\ntshark: There is no field named '%s'.\n",
 803                                                 field);
 804                                         g_free(field);
 805                                         exit(10);
 806                                 }
 807
 808                                 io->items[i].hf_index=hfi->id;
 809                                 break;
 810                         }
 811                 } else {
 812                         if (io->items[i].calc_type==CALC_TYPE_FRAMES || io->items[i].calc_type==CALC_TYPE_BYTES)
 813                                 flt="";
 814                 }
 815         }
 816         if(hfi && !(io->items[i].calc_type==CALC_TYPE_BYTES ||
 817                             io->items[i].calc_type==CALC_TYPE_FRAMES ||
 818                             io->items[i].calc_type==CALC_TYPE_FRAMES_AND_BYTES)){
 819                 /* check that the type is compatible */
 820                 switch(hfi->type){
 821                 case FT_UINT8:
 822                 case FT_UINT16:
 823                 case FT_UINT24:
 824                 case FT_UINT32:
 825                 case FT_UINT64:
 826                 case FT_INT8:
 827                 case FT_INT16:
 828                 case FT_INT24:
 829                 case FT_INT32:
 830                 case FT_INT64:
 831                         /* these types support all calculations */
 832                         break;
 833                 case FT_FLOAT:
 834                 case FT_DOUBLE:
 835                         /* these types only support SUM, COUNT, MAX, MIN, AVG */
 836                         switch(io->items[i].calc_type){
 837                         case CALC_TYPE_SUM:
 838                         case CALC_TYPE_COUNT:
 839                         case CALC_TYPE_MAX:
 840                         case CALC_TYPE_MIN:
 841                         case CALC_TYPE_AVG:
 842                                 break;
 843                         default:
 844                                 fprintf(stderr,
 845                                         "\ntshark: %s is a float field, so %s(*) calculations are not supported on it.",
 846                                         field,
 847                                         calc_type_table[j].func_name);
 848                                 exit(10);
 849                         }
 850                         break;
 851                 case FT_RELATIVE_TIME:
 852                         /* this type only supports SUM, COUNT, MAX, MIN, AVG, LOAD */
 853                         switch(io->items[i].calc_type){
 854                         case CALC_TYPE_SUM:
 855                         case CALC_TYPE_COUNT:
 856                         case CALC_TYPE_MAX:
 857                         case CALC_TYPE_MIN:
 858                         case CALC_TYPE_AVG:
 859                         case CALC_TYPE_LOAD:
 860                                 break;
 861                         default:
 862                                 fprintf(stderr,
 863                                         "\ntshark: %s is a relative-time field, so %s(*) calculations are not supported on it.",
 864                                     field,
 865                                     calc_type_table[j].func_name);
 866                                 exit(10);
 867                         }
 868                         break;
 869                 default:
 870                         /*
 871                          * XXX - support all operations on floating-point
 872                          * numbers?
 873                          */
 874                         if(io->items[i].calc_type!=CALC_TYPE_COUNT){
 875                                 fprintf(stderr,
 876                                         "\ntshark: %s doesn't have integral values, so %s(*) calculations are not supported on it.\n",
 877                                     field,
 878                                     calc_type_table[j].func_name);
 879                                 exit(10);
 880                         }
 881                         break;
 882                 }
 883                 g_free(field);
 884         }
 885
 886         error_string=register_tap_listener("frame", &io->items[i], flt, TL_REQUIRES_PROTO_TREE, NULL, iostat_packet, i?NULL:iostat_draw);
 887         if(error_string){
 888                 g_free(io->items);
 889                 g_free(io);
 890                 fprintf(stderr, "\ntshark: Couldn't register io,stat tap: %s\n",
 891                     error_string->str);
 892                 g_string_free(error_string, TRUE);
 893                 exit(1);
 894         }
 895 }
 896
 897 static void
 898 iostat_init(const char *optarg, void* userdata _U_)
 899 {
 900         gdouble interval_float;
 901         gint64 interval;
 902         int idx=0;
 903         io_stat_t *io;
 904         const char *filter=NULL;
 905
 906         if(sscanf(optarg,"io,stat,%lf,%n",&interval_float,&idx)==1){
 907                 if(idx){
 908                         if(*(optarg+idx)==',')
 909                                 filter=optarg+idx+1;
 910                         else
 911                                 filter=optarg+idx;
 912                 } else {
 913                         filter=NULL;
 914                 }
 915         } else {
 916                 fprintf(stderr, "\ntshark: invalid \"-z io,stat,<interval>[,<filter>]\" argument\n");
 917                 exit(1);
 918         }
 919
 920         /* if interval is 0, calculate statistics over the whole file
 921          * by setting the interval to G_MAXINT32
 922          */
 923         if(interval_float==0) {
 924                 interval=G_MAXINT32;
 925         } else {
 926                 /* make interval be number of us rounded to the nearest integer*/
 927                 interval=(gint64)(interval_float*1000000.0+0.5);
 928         }
 929
 930         if(interval<1){
 931                 fprintf(stderr,
 932                         "\ntshark: \"-z\" interval must be >=0.000001 seconds or \"0\" for the entire capture duration.\n");
 933                 exit(10);
 934         }
 935
 936         io=g_malloc(sizeof(io_stat_t));
 937         io->interval=interval;
 938         if((!filter)||(filter[0]==0)){
 939                 io->num_items=1;
 940                 io->items=g_malloc(sizeof(io_stat_item_t)*io->num_items);
 941                 io->filters=g_malloc(sizeof(char *)*io->num_items);
 942
 943                 register_io_tap(io, 0, NULL);
 944         } else {
 945                 const char *str,*pos;
 946                 char *tmp;
 947                 int i;
 948                 /* find how many ',' separated filters we have */
 949                 str=filter;
 950                 io->num_items=1;
 951                 while((str=strchr(str,','))){
 952                         io->num_items++;
 953                         str++;
 954                 }
 955
 956                 io->items=g_malloc(sizeof(io_stat_item_t)*io->num_items);
 957                 io->filters=g_malloc(sizeof(char *)*io->num_items);
 958
 959                 /* for each filter, register a tap listener */
 960                 i=0;
 961                 str=filter;
 962                 do{
 963                         pos=strchr(str,',');
 964                         if(pos==str){
 965                                 register_io_tap(io, i, NULL);
 966                         } else if(pos==NULL) {
 967                                 tmp=g_strdup(str);
 968                                 register_io_tap(io, i, tmp);
 969                         } else {
 970                                 tmp=g_malloc((pos-str)+1);
 971                                 g_strlcpy(tmp,str,(pos-str)+1);
 972                                 register_io_tap(io, i, tmp);
 973                         }
 974                         str=pos+1;
 975                         i++;
 976                 } while(pos);
 977         }
 978 }
 979
 980 void
 981 register_tap_listener_iostat(void)
 982 {
 983         register_stat_cmd_arg("io,stat,", iostat_init, NULL);
 984 }