Don't use PCRE if we have GRegex.
[obnox/wireshark/wip.git] / 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 #include "register.h"
42
43
44 typedef struct _io_stat_t {
45         gint32 interval;        /* unit is ms */
46         guint32 num_items;
47         struct _io_stat_item_t *items;
48         const char **filters;
49 } io_stat_t;    
50
51 #define CALC_TYPE_BYTES 0
52 #define CALC_TYPE_COUNT 1
53 #define CALC_TYPE_SUM   2
54 #define CALC_TYPE_MIN   3
55 #define CALC_TYPE_MAX   4
56 #define CALC_TYPE_AVG   5
57
58 typedef struct _io_stat_item_t {
59         io_stat_t *parent;
60         struct _io_stat_item_t *next;
61         struct _io_stat_item_t *prev;
62         gint32 time;            /* unit is ms since start of capture */
63         int calc_type;
64         int hf_index;
65         guint32 frames;
66         guint32 num;
67         guint32 counter;
68 } io_stat_item_t;
69
70
71 static int
72 iostat_packet(void *arg, packet_info *pinfo, epan_dissect_t *edt, const void *dummy _U_)
73 {
74         io_stat_item_t *mit = arg;
75         io_stat_item_t *it;
76         gint32 current_time;
77         GPtrArray *gp;
78         guint i;
79
80         current_time=(gint32) ((pinfo->fd->rel_ts.secs*1000)+(pinfo->fd->rel_ts.nsecs/1000000));
81
82         /* the prev item before the main one is always the last interval we saw packets for */
83         it=mit->prev;
84
85         /* XXX for the time being, just ignore all frames that are in the past.
86            should be fixed in the future but hopefully it is uncommon */
87         if(current_time<it->time){
88                 return FALSE;
89         }
90
91         /* we have moved into a new interval, we need to create a new struct */
92         if(current_time>=(it->time+mit->parent->interval)){
93                 it->next=g_malloc(sizeof(io_stat_item_t));
94                 it->next->prev=it;
95                 it->next->next=NULL;
96                 it=it->next;
97                 mit->prev=it;
98
99                 it->time=(current_time / mit->parent->interval) * mit->parent->interval;
100                 it->frames=0;
101                 it->counter=0;
102                 it->num=0;
103                 it->calc_type=it->prev->calc_type;
104                 it->hf_index=it->prev->hf_index;
105         }
106
107         /* it will now give us the current structure to use to store the data in */
108         it->frames++;
109
110         switch(it->calc_type){
111         case CALC_TYPE_BYTES:
112                 it->counter+=pinfo->fd->pkt_len;
113                 break;
114         case CALC_TYPE_COUNT:
115                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
116                 if(gp){
117                         it->counter+=gp->len;
118                 }
119                 break;
120         case CALC_TYPE_SUM:
121                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
122                 if(gp){
123                         for(i=0;i<gp->len;i++){
124                                 switch(proto_registrar_get_ftype(it->hf_index)){
125                                 case FT_UINT8:
126                                 case FT_UINT16:
127                                 case FT_UINT24:
128                                 case FT_UINT32:
129                                         it->counter+=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
130                                         break;
131                                 case FT_INT8:
132                                 case FT_INT16:
133                                 case FT_INT24:
134                                 case FT_INT32:
135                                         it->counter+=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
136                                         break;
137                                 }
138                         }
139                 }
140                 break;
141         case CALC_TYPE_MIN:
142                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
143                 if(gp){
144                         int type;
145                         guint32 val;
146                         nstime_t *new_time;
147
148                         type=proto_registrar_get_ftype(it->hf_index);
149                         for(i=0;i<gp->len;i++){
150                                 switch(type){
151                                 case FT_UINT8:
152                                 case FT_UINT16:
153                                 case FT_UINT24:
154                                 case FT_UINT32:
155                                         val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
156                                         if((it->frames==1)&&(i==0)){
157                                                 it->counter=val;
158                                         } else if(val<it->counter){
159                                                 it->counter=val;
160                                         }                               
161                                         break;
162                                 case FT_INT8:
163                                 case FT_INT16:
164                                 case FT_INT24:
165                                 case FT_INT32:
166                                         val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
167                                         if((it->frames==1)&&(i==0)){
168                                                 it->counter=val;
169                                         } else if((gint32)val<(gint32)(it->counter)){
170                                                 it->counter=val;
171                                         }
172                                         break;
173                                 case FT_RELATIVE_TIME:
174                                         new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
175                                         val=(guint32) (new_time->secs*1000+new_time->nsecs/1000000);
176                                         if((it->frames==1)&&(i==0)){
177                                                 it->counter=val;
178                                         } else if(val<it->counter){
179                                                 it->counter=val;
180                                         }                               
181                                         break;
182                                 }
183                         }
184                 }
185                 break;
186         case CALC_TYPE_MAX:
187                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
188                 if(gp){
189                         int type;
190                         guint32 val;
191                         nstime_t *new_time;
192
193                         type=proto_registrar_get_ftype(it->hf_index);
194                         for(i=0;i<gp->len;i++){
195                                 switch(type){
196                                 case FT_UINT8:
197                                 case FT_UINT16:
198                                 case FT_UINT24:
199                                 case FT_UINT32:
200                                         val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
201                                         if((it->frames==1)&&(i==0)){
202                                                 it->counter=val;
203                                         } else if(val>it->counter){
204                                                 it->counter=val;
205                                         }                               
206                                         break;
207                                 case FT_INT8:
208                                 case FT_INT16:
209                                 case FT_INT24:
210                                 case FT_INT32:
211                                         val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
212                                         if((it->frames==1)&&(i==0)){
213                                                 it->counter=val;
214                                         } else if((gint32)val>(gint32)(it->counter)){
215                                                 it->counter=val;
216                                         }                               
217                                         break;
218                                 case FT_RELATIVE_TIME:
219                                         new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
220                                         val=(guint32) (new_time->secs*1000+new_time->nsecs/1000000);
221                                         if((it->frames==1)&&(i==0)){
222                                                 it->counter=val;
223                                         } else if(val>it->counter){
224                                                 it->counter=val;
225                                         }                               
226                                         break;
227                                 }
228                         }
229                 }
230                 break;
231         case CALC_TYPE_AVG:
232                 gp=proto_get_finfo_ptr_array(edt->tree, it->hf_index);
233                 if(gp){
234                         int type;
235                         guint32 val;
236                         nstime_t *new_time;
237
238                         type=proto_registrar_get_ftype(it->hf_index);
239                         for(i=0;i<gp->len;i++){
240                                 it->num++;
241                                 switch(type){
242                                 case FT_UINT8:
243                                 case FT_UINT16:
244                                 case FT_UINT24:
245                                 case FT_UINT32:
246                                         val=fvalue_get_uinteger(&((field_info *)gp->pdata[i])->value);
247                                         it->counter+=val;
248                                         break;
249                                 case FT_INT8:
250                                 case FT_INT16:
251                                 case FT_INT24:
252                                 case FT_INT32:
253                                         val=fvalue_get_sinteger(&((field_info *)gp->pdata[i])->value);
254                                         it->counter+=val;
255                                         break;
256                                 case FT_RELATIVE_TIME:
257                                         new_time=fvalue_get(&((field_info *)gp->pdata[i])->value);
258                                         val=(guint32) (new_time->secs*1000+new_time->nsecs/1000000);
259                                         it->counter+=val;
260                                         break;
261                                 }
262                         }
263                 }
264                 break;
265         }
266
267         return TRUE;
268 }
269
270 static void
271 iostat_draw(void *arg)
272 {
273         io_stat_item_t *mit = arg;
274         io_stat_t *iot;
275         io_stat_item_t **items;
276         guint32 *frames;
277         guint32 *counters;
278         guint32 *num;
279         guint32 i,more_items;
280         gint t;
281
282         iot=mit->parent;
283
284         printf("\n");
285         printf("===================================================================\n");
286         printf("IO Statistics\n");
287         if(iot->interval!=G_MAXINT32) 
288                 printf("Interval: %d.%03d secs\n", iot->interval/1000, iot->interval%1000);
289         for(i=0;i<iot->num_items;i++){
290                 printf("Column #%d: %s\n",i,iot->filters[i]?iot->filters[i]:"");
291         }
292         printf("                ");
293         for(i=0;i<iot->num_items;i++){
294                 printf("|   Column #%-2d   ",i);
295         }
296         printf("\n");
297         printf("Time            ");
298         for(i=0;i<iot->num_items;i++){
299                 switch(iot->items[i].calc_type){
300                 case CALC_TYPE_BYTES:
301                         printf("|frames|  bytes  ");
302                         break;
303                 case CALC_TYPE_COUNT:
304                         printf("|          COUNT ");
305                         break;
306                 case CALC_TYPE_SUM:
307                         printf("|            SUM ");
308                         break;
309                 case CALC_TYPE_MIN:
310                         printf("|            MIN ");
311                         break;
312                 case CALC_TYPE_MAX:
313                         printf("|            MAX ");
314                         break;
315                 case CALC_TYPE_AVG:
316                         printf("|            AVG ");
317                         break;
318                 }
319         }
320         printf("\n");
321
322         items=g_malloc(sizeof(io_stat_item_t *)*iot->num_items);
323         frames=g_malloc(sizeof(guint32)*iot->num_items);
324         counters=g_malloc(sizeof(guint32)*iot->num_items);
325         num=g_malloc(sizeof(guint32)*iot->num_items);
326         /* preset all items at the first interval */
327         for(i=0;i<iot->num_items;i++){
328                 items[i]=&iot->items[i];
329         }
330
331         /* loop the items until we run out of them all */
332         t=0;
333         do {
334                 more_items=0;
335                 for(i=0;i<iot->num_items;i++){
336                         frames[i]=0;
337                         counters[i]=0;
338                         num[i]=0;
339                 }
340                 for(i=0;i<iot->num_items;i++){
341                         if(items[i] && (t>=(items[i]->time+iot->interval))){
342                                 items[i]=items[i]->next;
343                         }
344
345                         if(items[i] && (t<(items[i]->time+iot->interval)) && (t>=items[i]->time) ){
346                                 frames[i]=items[i]->frames;
347                                 counters[i]=items[i]->counter;
348                                 num[i]=items[i]->num;
349                         }
350
351                         if(items[i]){
352                                 more_items=1;
353                         }
354                 }
355
356                 if(more_items){
357                         if(iot->interval==G_MAXINT32) {
358                                 printf("000.000-         ");
359                         } else {
360                                 printf("%03d.%03d-%03d.%03d  ",
361                                         t/1000,t%1000,
362                                         (t+iot->interval)/1000,
363                                         (t+iot->interval)%1000);
364                         }
365                         for(i=0;i<iot->num_items;i++){
366                                 switch(iot->items[i].calc_type){
367                                 case CALC_TYPE_BYTES:
368                                         printf("%6d %9d ",frames[i],counters[i]);
369                                         break;
370                                 case CALC_TYPE_COUNT:
371                                         printf("        %8d ", counters[i]);
372                                         break;
373                                 case CALC_TYPE_SUM:
374                                         printf("        %8d ", counters[i]);
375                                         break;
376                                 case CALC_TYPE_MIN:
377                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
378                                         case FT_UINT8:
379                                         case FT_UINT16:
380                                         case FT_UINT24:
381                                         case FT_UINT32:
382                                                 printf("        %8u ", counters[i]);
383                                                 break;
384                                         case FT_INT8:
385                                         case FT_INT16:
386                                         case FT_INT24:
387                                         case FT_INT32:
388                                                 printf("        %8d ", counters[i]);
389                                                 break;
390                                         case FT_RELATIVE_TIME:
391                                                 printf("      %6d.%03d ", counters[i]/1000, counters[i]%1000);
392                                                 break;
393                                         }
394                                         break;
395                                 case CALC_TYPE_MAX:
396                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
397                                         case FT_UINT8:
398                                         case FT_UINT16:
399                                         case FT_UINT24:
400                                         case FT_UINT32:
401                                                 printf("        %8u ", counters[i]);
402                                                 break;
403                                         case FT_INT8:
404                                         case FT_INT16:
405                                         case FT_INT24:
406                                         case FT_INT32:
407                                                 printf("        %8d ", counters[i]);
408                                                 break;
409                                         case FT_RELATIVE_TIME:
410                                                 printf("      %6d.%03d ", counters[i]/1000, counters[i]%1000);
411                                                 break;
412                                         }
413                                         break;
414                                 case CALC_TYPE_AVG:
415                                         if(num[i]==0){
416                                                 num[i]=1;
417                                         }
418                                         switch(proto_registrar_get_ftype(iot->items[i].hf_index)){
419                                         case FT_UINT8:
420                                         case FT_UINT16:
421                                         case FT_UINT24:
422                                         case FT_UINT32:
423                                                 printf("        %8u ", counters[i]/num[i]);
424                                                 break;
425                                         case FT_INT8:
426                                         case FT_INT16:
427                                         case FT_INT24:
428                                         case FT_INT32:
429                                                 printf("        %8d ", counters[i]/num[i]);
430                                                 break;
431                                         case FT_RELATIVE_TIME:
432                                                 counters[i]/=num[i];
433                                                 printf("      %6d.%03d ", counters[i]/1000, counters[i]%1000);
434                                                 break;
435                                         }
436                                         break;
437
438                                 }
439                         }
440                         printf("\n");
441                 }
442
443                 t+=iot->interval;
444         } while(more_items);
445
446         printf("===================================================================\n");
447
448         g_free(items);
449         g_free(frames);
450         g_free(counters);
451         g_free(num);
452 }
453
454
455 typedef struct {
456         const char *func_name;
457         int calc_type;
458 } calc_type_ent_t;
459
460 static calc_type_ent_t calc_type_table[] = {
461         { "COUNT", CALC_TYPE_COUNT },
462         { "SUM", CALC_TYPE_SUM },
463         { "MIN", CALC_TYPE_MIN },
464         { "MAX", CALC_TYPE_MAX },
465         { "AVG", CALC_TYPE_AVG },
466         { NULL, 0 }
467 };
468
469 static void
470 register_io_tap(io_stat_t *io, int i, const char *filter)
471 {
472         GString *error_string;
473         const char *flt;
474         int j;
475         size_t namelen;
476         const char *p, *parenp;
477         char *field;
478         header_field_info *hfi;
479
480         io->items[i].prev=&io->items[i];
481         io->items[i].next=NULL;
482         io->items[i].parent=io;
483         io->items[i].time=0;
484         io->items[i].calc_type=CALC_TYPE_BYTES;
485         io->items[i].frames=0;
486         io->items[i].counter=0;
487         io->items[i].num=0;
488         io->filters[i]=filter;
489         flt=filter;
490
491         field=NULL;
492         hfi=NULL;
493         for(j=0; calc_type_table[j].func_name; j++){
494                 namelen=strlen(calc_type_table[j].func_name);
495                 if(filter
496                     && strncmp(filter, calc_type_table[j].func_name, namelen) == 0
497                     && *(filter+namelen)=='('){
498                         io->items[i].calc_type=calc_type_table[j].calc_type;
499
500                         p=filter+namelen+1;
501                         parenp=strchr(p, ')');
502                         if(!parenp){
503                                 fprintf(stderr, "tshark: Closing parenthesis missing from calculated expression.\n");
504                                 exit(10);
505                         }
506                         /* bail out if there was no field specified */
507                         if(parenp==p){
508                                 fprintf(stderr, "tshark: You didn't specify a field name for %s(*).\n",
509                                     calc_type_table[j].func_name);
510                                 exit(10);
511                         }
512                         field=g_malloc(parenp-p+1);
513                         if(!field){
514                                 fprintf(stderr, "tshark: Out of memory.\n");
515                                 exit(10);
516                         }
517                         memcpy(field, p, parenp-p);
518                         field[parenp-p] = '\0';
519                         flt=parenp + 1;
520
521                         hfi=proto_registrar_get_byname(field);
522                         if(!hfi){
523                                 fprintf(stderr, "tshark: There is no field named '%s'.\n",
524                                     field);
525                                 g_free(field);
526                                 exit(10);
527                         }
528         
529                         io->items[i].hf_index=hfi->id;
530                         break;
531                 }
532         }
533         if(hfi && io->items[i].calc_type!=CALC_TYPE_BYTES){
534                 /* check that the type is compatible */
535                 switch(hfi->type){
536                 case FT_UINT8:
537                 case FT_UINT16:
538                 case FT_UINT24:
539                 case FT_UINT32:
540                 case FT_INT8:
541                 case FT_INT16:
542                 case FT_INT24:
543                 case FT_INT32:
544                         /* these types support all calculations */
545                         break;
546                 case FT_RELATIVE_TIME:
547                         /* this type only supports SUM, COUNT, MAX, MIN, AVG */
548                         switch(io->items[i].calc_type){
549                         case CALC_TYPE_SUM:
550                         case CALC_TYPE_COUNT:
551                         case CALC_TYPE_MAX:
552                         case CALC_TYPE_MIN:
553                         case CALC_TYPE_AVG:
554                                 break;
555                         default:
556                                 fprintf(stderr,
557                                     "tshark: %s is a relative-time field, so %s(*) calculations are not supported on it.",
558                                     field,
559                                     calc_type_table[j].func_name);
560                                 exit(10);
561                         }
562                         break;
563                 case FT_UINT64:
564                 case FT_INT64:
565                         /*
566                          * XXX - support this if gint64/guint64 are
567                          * available?
568                          */
569                         if(io->items[i].calc_type!=CALC_TYPE_COUNT){
570                                 fprintf(stderr,
571                                     "tshark: %s is a 64-bit integer, so %s(*) calculations are not supported on it.",
572                                     field,
573                                     calc_type_table[j].func_name);
574                                 exit(10);
575                         }
576                         break;
577                 default:
578                         /*
579                          * XXX - support all operations on floating-point
580                          * numbers?
581                          */
582                         if(io->items[i].calc_type!=CALC_TYPE_COUNT){
583                                 fprintf(stderr,
584                                     "tshark: %s doesn't have integral values, so %s(*) calculations are not supported on it.\n",
585                                     field,
586                                     calc_type_table[j].func_name);
587                                 exit(10);
588                         }
589                         break;
590                 }
591                 g_free(field);
592         }
593
594 /*
595 CALC_TYPE_SUM   2
596 CALC_TYPE_MIN   3
597 CALC_TYPE_MAX   4
598 CALC_TYPE_AVG   5
599 */
600
601         error_string=register_tap_listener("frame", &io->items[i], flt, TL_REQUIRES_PROTO_TREE, NULL, iostat_packet, i?NULL:iostat_draw);
602         if(error_string){
603                 g_free(io->items);
604                 g_free(io);
605                 fprintf(stderr, "tshark: Couldn't register io,stat tap: %s\n",
606                     error_string->str);
607                 g_string_free(error_string, TRUE);
608                 exit(1);
609         }
610 }
611
612 static void
613 iostat_init(const char *optarg, void* userdata _U_)
614 {
615         float interval_float;
616         gint32 interval; 
617         int idx=0;
618         io_stat_t *io;
619         const char *filter=NULL;
620
621         if(sscanf(optarg,"io,stat,%f,%n",&interval_float,&idx)==1){
622                 if(idx){
623                         filter=optarg+idx;
624                 } else {
625                         filter=NULL;
626                 }
627         } else {
628                 fprintf(stderr, "tshark: invalid \"-z io,stat,<interval>[,<filter>]\" argument\n");
629                 exit(1);
630         }
631
632         /* if interval is 0, calculate statistics over the whole file
633          * by setting the interval to G_MAXINT32
634          */
635         if(interval_float==0) {
636                 interval=G_MAXINT32;
637         } else {
638                 /* make interval be number of ms */
639                 interval=(gint32)(interval_float*1000.0+0.9);   
640         }
641
642         if(interval<1){
643                 fprintf(stderr, "tshark: \"-z\" interval must be >=0.001 seconds or 0.\n");
644                 exit(10);
645         }
646         
647         io=g_malloc(sizeof(io_stat_t));
648         io->interval=interval;
649         if((!filter)||(filter[0]==0)){
650                 io->num_items=1;
651                 io->items=g_malloc(sizeof(io_stat_item_t)*io->num_items);
652                 io->filters=g_malloc(sizeof(char *)*io->num_items);
653
654                 register_io_tap(io, 0, NULL);
655         } else {
656                 const char *str,*pos;
657                 char *tmp;
658                 int i;
659                 /* find how many ',' separated filters we have */
660                 str=filter;
661                 io->num_items=1;
662                 while((str=strchr(str,','))){
663                         io->num_items++;
664                         str++;
665                 }
666
667                 io->items=g_malloc(sizeof(io_stat_item_t)*io->num_items);
668                 io->filters=g_malloc(sizeof(char *)*io->num_items);
669
670                 /* for each filter, register a tap listener */          
671                 i=0;
672                 str=filter;
673                 do{
674                         pos=strchr(str,',');
675                         if(pos==str){
676                                 register_io_tap(io, i, NULL);
677                         } else if(pos==NULL) {
678                                 tmp=g_strdup(str);
679                                 register_io_tap(io, i, tmp);
680                         } else {
681                                 tmp=g_malloc((pos-str)+1);
682                                 g_strlcpy(tmp,str,(pos-str)+1);
683                                 register_io_tap(io, i, tmp);
684                         }
685                         str=pos+1;
686                         i++;                    
687                 } while(pos);
688         }                       
689 }
690
691 void
692 register_tap_listener_iostat(void)
693 {
694         register_stat_cmd_arg("io,stat,", iostat_init, NULL);
695 }