← Back to branch summary

~ubuntu-branches/ubuntu/natty/ntop/natty

« back to all changes in this revision

Viewing changes to graph.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2005-01-30 21:59:13 UTC
  • mfrom: (2.1.1 warty)
  • Revision ID: james.westby@ubuntu.com-20050130215913-xc3ke963bw49b3k4
Tags: 2:3.0-5
http://bugs.debian.org/291794
http://bugs.debian.org/287802
http://bugs.debian.org/252352
http://bugs.debian.org/267248
http://bugs.debian.org/269321
http://bugs.debian.org/269319
* Updated README.Debian file so users will understand what to do at
  install, closes: #291794, #287802.
* Updated ntop init script to give better output.
* Also changed log directory from /var/lib/ntop to /var/log/ntop,
  closes: #252352.
* Quoted the interface list to allow whitespace, closes: #267248.
* Added a couple of logcheck ignores, closes: #269321, #269319.

Show diffs side-by-side

added added

removed removed

Lines of Context:
graph.c
 
1
/*
 
2
 *  Copyright (C) 1998-2004 Luca Deri <deri@ntop.org>
 
3
 *
 
4
 *                          http://www.ntop.org/
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
19
 */
 
20
 
 
21
/*
 
22
 * Do not use local defs for pnggraph
 
23
 * (included by ntop.h)
 
24
 */
 
25
 
 
26
#include "ntop.h"
 
27
 
 
28
#ifndef EMBEDDED
 
29
 
 
30
#define _GRAPH_C_
 
31
#include "globals-report.h"
 
32
 
 
33
static unsigned long clr[] = { 0xf08080L, 0x4682b4L, 0x66cdaaL,
 
34
                               0xf4a460L, 0xb0c4deL, 0x90ee90L,
 
35
                               0xffd700L, 0x87ceebL, 0xdda0ddL,
 
36
                               0x7fffd4L, 0xffb6c1L, 0x708090L,
 
37
                               0x6495edL, 0xdeb887L, 0x6b8e23L,
 
38
                               0xf08080L, 0x4682b4L, 0x66cdaaL,
 
39
                               0xf4a460L, 0xb0c4deL, 0x90ee90L,
 
40
                               0xffd700L, 0x87ceebL, 0xdda0ddL };
 
41
 
 
42
/* ******************************************************************* */
 
43
 
 
44
#include "gd.h"
 
45
#include "gdfontl.h"
 
46
#include "gdfonts.h"
 
47
#include "gdfontmb.h"
 
48
#define M_PI    3.14159265358979323846
 
49
 
 
50
#include <stdio.h>
 
51
 
 
52
/* ******************************************************************* */
 
53
 
 
54
/**********************************************************/
 
55
/* Guess at the version of gd from various breadcrumbs in */
 
56
/* the library (only things checkable at run-time, since  */
 
57
/* just because it was compiled against a version doesn't */
 
58
/* mean that's what it's running on...)                   */
 
59
/**********************************************************/
 
60
 
 
61
char* gdVersionGuess(void) {
 
62
#ifdef WIN32
 
63
#if GD2_VERS == 2 /* GD 2.x detected */    
 
64
    return("2.x");
 
65
#else
 
66
    return("1.8.x");
 
67
#endif
 
68
#else
 
69
#if (defined(HAVE_DIRENT_H) && defined(HAVE_DLFCN_H)) || defined(DARWIN)
 
70
  void *gdPtr = NULL;
 
71
 
 
72
  gdPtr = (void*)dlopen(CONST_LIBGD_SO, RTLD_NOW); /* Load the library */
 
73
 
 
74
  if(gdPtr == NULL) {
 
75
    traceEvent(CONST_TRACE_WARNING, "GDVERCHK: Unable to load gd, message is '%s'", dlerror());
 
76
#if GD2_VERS == 2 /* GD 2.x detected */    
 
77
    return("2.x");
 
78
#else
 
79
    return("1.8.x");
 
80
#endif
 
81
  }
 
82
 
 
83
#define test_gd_function(a, b)   if((void*)dlsym(gdPtr, a) != NULL) { dlclose(gdPtr); return(b); }
 
84
 
 
85
  test_gd_function("gdImageCreateFromPngPtr", "2.0.21+");
 
86
  test_gd_function("gdFontCacheSetup", "2.0.16-2.0.20");
 
87
  test_gd_function("gdImageSetClip", "2.0.12-2.0.15");
 
88
  test_gd_function("gdImageCopyRotated", "2.0.8-2.0.11");
 
89
  test_gd_function("gdImageStringFTEx", "2.0.5-2.0.7");
 
90
  test_gd_function("gdFreeFontCache", "2.0.4");
 
91
  test_gd_function("gdImageCreateTrueColor", "2.0.0-2.0.3");
 
92
  test_gd_function("gdImageCreateFromJpeg", "1.8.4");
 
93
 
 
94
#undef test_gd_function
 
95
 
 
96
  dlclose(gdPtr);
 
97
 
 
98
  return("1.8.3 or below");
 
99
 
 
100
#else
 
101
 
 
102
  return(NULL);
 
103
#endif
 
104
#endif
 
105
}
 
106
 
 
107
/* ************************************************** */
 
108
 
 
109
static void drawLegend(gdImagePtr im,
 
110
                       short width,
 
111
                       short height,
 
112
                       int   num_points,
 
113
                       char  *labels[],              /* slice labels */
 
114
                       float data[],
 
115
                       int colors[], int labelColor) {
 
116
 
 
117
  int edge_x, edge_y, i;
 
118
#ifdef SHOW_PERCENTAGE
 
119
  float total;
 
120
  char str[32];
 
121
#endif
 
122
 
 
123
  edge_x = (width*.75)+10;
 
124
  edge_y = (height/10);
 
125
 
 
126
#ifdef SHOW_PERCENTAGE
 
127
  for(i=0, total=0; i<num_points; i++)
 
128
    total += data[i];
 
129
#endif
 
130
 
 
131
  for(i=0; i<num_points; i++) {
 
132
    gdImageFilledRectangle(im, edge_x, edge_y, edge_x+CONST_LEGEND_BOX_SIZE, 
 
133
                           edge_y+CONST_LEGEND_BOX_SIZE, colors[i]);
 
134
    gdImageRectangle(im, edge_x-1, edge_y-1, edge_x+CONST_LEGEND_BOX_SIZE+1,
 
135
                     edge_y+CONST_LEGEND_BOX_SIZE+1, labelColor);
 
136
#ifdef SHOW_PERCENTAGE
 
137
    if(snprintf(str, sizeof(str), "%s(%.1f%%)", labels[i], (data[i]*100)/total) < 0)
 
138
      BufferTooShort();
 
139
    gdImageString(im, gdFontSmall, edge_x+CONST_LEGEND_BOX_SIZE+5, edge_y-5, str, labelColor);
 
140
#else
 
141
    gdImageString(im, gdFontSmall, edge_x+CONST_LEGEND_BOX_SIZE+5, edge_y-3, labels[i], labelColor);
 
142
#endif
 
143
    edge_y += gdFontSmall->h*1.5;
 
144
  }
 
145
}
 
146
 
 
147
/* ************************ */
 
148
 
 
149
void drawPie(short width,
 
150
             short height,
 
151
             FILE* filepointer,            /* open file pointer, can be stdout */
 
152
             int   num_points,
 
153
             char  *labels[],              /* slice labels */
 
154
             float data[] ) {
 
155
  gdImagePtr im;
 
156
  int black, white, colors[64], numColors, i;
 
157
  int center_x, center_y, radius, begDeg, endDeg, x, y;
 
158
  float total;
 
159
  int displ;
 
160
  float radiant;
 
161
 
 
162
  im = gdImageCreate(width, height);
 
163
 
 
164
  white = gdImageColorAllocate(im, 255, 255, 255); /* bg color */
 
165
  black = gdImageColorAllocate(im, 0, 0, 0);
 
166
  numColors = sizeof(clr)/sizeof(unsigned long);
 
167
  for(i=0; i<numColors; i++) {
 
168
    colors[i] = gdImageColorAllocate(im, clr[i]>>16, clr[i]>>8, clr[i]&0x0000FF);
 
169
  }
 
170
 
 
171
  /* ******************************* */
 
172
 
 
173
  for(i=0, total=0; i<num_points; i++)
 
174
    total += data[i];
 
175
 
 
176
  center_x = width/3, center_y = height/2;
 
177
  radius = height/3;
 
178
  begDeg = 0;
 
179
 
 
180
  gdImageArc(im, center_x, center_y, 2*radius, 2*radius, 0, 360, black);
 
181
  radiant = begDeg-90; radiant /= 360; radiant *= 2*M_PI;
 
182
  x = center_x+(radius)*cos(radiant);
 
183
  y = center_y+(radius)*sin(radiant);
 
184
  gdImageLine(im, center_x, center_y, x,y, black);
 
185
 
 
186
  /* Safety check */
 
187
  if(num_points == 0) {
 
188
    num_points = 1;
 
189
    data[0] = 1;
 
190
  }
 
191
 
 
192
  for(i=0; i<num_points; i++) {
 
193
    displ = (360*data[i])/total;
 
194
 
 
195
    if(i < (num_points-1))
 
196
      endDeg = begDeg+displ;
 
197
    else
 
198
      endDeg = 360;
 
199
   
 
200
#if GD2_VERS == 2 /* GD 2.x detected */    
 
201
    gdImageFilledArc(im, center_x, center_y, 2*radius, 2*radius,                     
 
202
                     begDeg+270, endDeg+270, colors[i], gdArc);
 
203
#else
 
204
    radiant = begDeg-90; radiant /= 360; radiant *= 2*M_PI;
 
205
    x = center_x+(radius)*cos(radiant);
 
206
    y = center_y+(radius)*sin(radiant);
 
207
    gdImageArc(im, center_x, center_y, 2*radius, 2*radius,
 
208
               begDeg+270, endDeg+270, black);
 
209
    gdImageLine(im, center_x, center_y, x,y, black);
 
210
 
 
211
    begDeg = (begDeg+endDeg)/2;
 
212
    radiant = begDeg-90; radiant /= 360; radiant *= 2*M_PI;
 
213
    x = center_x+(radius/2)*cos(radiant);
 
214
    y = center_y+(radius/2)*sin(radiant);
 
215
    gdImageFillToBorder(im, x, y, black, colors[i]);
 
216
#endif
 
217
 
 
218
    begDeg = endDeg;
 
219
  }
 
220
 
 
221
#if GD2_VERS == 2 /* GD 2.x detected */
 
222
  gdImageArc(im, center_x, center_y, 2*radius, 2*radius, 0, 360, black);
 
223
#endif
 
224
 
 
225
  drawLegend(im, width, height, num_points, labels, data, colors, black);
 
226
  gdImagePng(im, filepointer);
 
227
  gdImageDestroy(im);
 
228
}
 
229
 
 
230
/* ************************ */
 
231
 
 
232
/* Fix for large numbers (over 4Gb) courtesy of
 
233
   Kouprie Robbert <r.kouprie@dto.tudelft.nl>
 
234
*/
 
235
void drawBar(short width,
 
236
             short height,
 
237
             FILE* filepointer,  /* open file pointer, can be stdout */
 
238
             int   num_points,
 
239
             char  *labels[],    /* slice labels */
 
240
             float data[]) {
 
241
  gdImagePtr im;
 
242
  int black, white, gray, colors[64], numColors, i, ngrid, base, padding;
 
243
  int center_x, center_y, vmargin, hmargin, xsize, ysize, xpos, ypos, dypix;
 
244
  float maxval, total, yscale, txtsz, txtht;
 
245
  float dydat, xmax, ymax, xmin, ymin;
 
246
 
 
247
  im = gdImageCreate(width, height);
 
248
 
 
249
  white = gdImageColorAllocate(im, 255, 255, 255); /* bg color */
 
250
  black = gdImageColorAllocate(im, 0, 0, 0);
 
251
  gray = gdImageColorAllocate(im, 200, 200, 200);
 
252
  numColors = sizeof(clr)/sizeof(unsigned long);
 
253
  for(i=0; i<numColors; i++) {
 
254
    colors[i] = gdImageColorAllocate(im, clr[i]>>16, clr[i]>>8, clr[i]&0x0000FF);
 
255
  }
 
256
 
 
257
  /* ******************************* */
 
258
 
 
259
  maxval = 0;
 
260
 
 
261
  for(i=0, total=0; i<num_points; i++) {
 
262
    total += data[i];
 
263
    if(data[i] > maxval) maxval =  data[i];
 
264
  }
 
265
 
 
266
  center_x = width/3, center_y = height/2;
 
267
 
 
268
  /* ************************* */
 
269
 
 
270
  vmargin = 20; // top (bottom) vertical margin for title (x-labels)
 
271
  hmargin = 60; // left horizontal margin for y-labels
 
272
 
 
273
  base = floor((((width*.75)) - hmargin) / num_points); // distance between columns
 
274
 
 
275
  ysize = height - 2 * vmargin; // y-size of plot
 
276
  xsize = num_points * base; // x-size of plot
 
277
 
 
278
  // y labels and grid lines
 
279
  ngrid = 4; // number of grid lines
 
280
 
 
281
  dydat = maxval / ngrid; // data units between grid lines
 
282
  dypix = ysize / (ngrid + 1); // pixels between grid lines
 
283
 
 
284
  // make y-axis text label from height of grid line (in data units)
 
285
  for (i = 0; i <= (ngrid + 1); i++) {
 
286
    char buf[32];
 
287
    char *theStr = formatBytes(i * dydat, 0, buf, sizeof(buf)); // make label text
 
288
 
 
289
    txtsz = gdFontSmall->w*strlen(theStr); // pixel-width of label
 
290
    txtht = gdFontSmall->h; // pixel-height of label
 
291
 
 
292
    // height of grid line in pixels
 
293
    ypos = vmargin + ysize - (i*dypix);
 
294
    xpos = hmargin - 10 - txtsz;
 
295
    if(xpos < 1) xpos = 1;
 
296
 
 
297
    gdImageString(im, gdFontSmall, xpos, ypos - (int)(txtht/2), theStr, black);
 
298
 
 
299
    if (!(i == 0) && !(i > ngrid)) {
 
300
      gdImageLine(im, hmargin, ypos, hmargin + xsize, ypos, gray);
 
301
    }
 
302
  }
 
303
 
 
304
  // columns and x labels
 
305
  padding = 3; // half of spacing between columns
 
306
  yscale = (float)ysize/((ngrid+1) * dydat); // pixels per data unit
 
307
 
 
308
  for (i = 0; i<num_points; i++) {
 
309
    // vertical columns
 
310
    ymax = vmargin + ysize;
 
311
 
 
312
    if(ymax > (int)(data[i]*yscale)) {
 
313
      ymin = ymax - (int)(data[i]*yscale);
 
314
      if(ymin < vmargin) ymin = vmargin;
 
315
    }
 
316
    else
 
317
      ymin = vmargin;
 
318
 
 
319
    xmax = hmargin + (i+1)*base - padding;
 
320
    xmin = hmargin + i*base + padding;
 
321
 
 
322
    if((xmax-xmin) > 100) {
 
323
      xmax = xmin+100;
 
324
    }
 
325
 
 
326
    gdImageFilledRectangle(im, xmin, ymin, xmax, ymax, colors[i]);
 
327
    gdImageRectangle(im, xmin, ymin, xmax, ymax, black);
 
328
 
 
329
    // x labels
 
330
    txtsz = gdFontSmall->w * strlen(labels[i]);
 
331
 
 
332
    xpos = xmin + (int)((base - txtsz) / 2);
 
333
    if(xmin > xpos) xpos = xmin; else xmin = xpos;
 
334
    ypos = ymax + 3; // distance from x axis
 
335
  }
 
336
 
 
337
  // plot frame
 
338
  gdImageRectangle(im, hmargin, vmargin, hmargin + xsize, vmargin + ysize, black);
 
339
 
 
340
  /* ************************* */
 
341
 
 
342
  drawLegend(im, width, height, num_points, labels, data, colors, black);
 
343
  gdImagePng(im, filepointer);
 
344
  gdImageDestroy(im);
 
345
}
 
346
 
 
347
/* ************************** */
 
348
 
 
349
void drawArea(short width,
 
350
              short height,
 
351
              FILE* filepointer,            /* open file pointer, can be stdout */
 
352
              int   num_points,
 
353
              char  *labels[],              /* slice labels */
 
354
              float data[],
 
355
              char *xtitle,
 
356
              char *ytitle,
 
357
              u_short formatYlabels) {
 
358
  gdImagePtr im;
 
359
  int black, white, colors[64], numColors, i;
 
360
  float maxval=0;
 
361
  int center_x, center_y, base;
 
362
  float total, yscale, txtsz, txtht;
 
363
  float vmargin, hmargin, xsize, ysize, ngrid, dydat, dypix, ydat, xpos, ypos;
 
364
  float padding, ymax, ymin, xmax, xmin, gray;
 
365
  char str[16];
 
366
 
 
367
  im = gdImageCreate(width, height);
 
368
 
 
369
  white = gdImageColorAllocate(im, 255, 255, 255); /* bg color */
 
370
  black = gdImageColorAllocate(im, 0, 0, 0);
 
371
  gray = gdImageColorAllocate(im, 200, 200, 200);
 
372
  numColors = sizeof(clr)/sizeof(unsigned long);
 
373
  for(i=0; i<numColors; i++) {
 
374
    colors[i] = gdImageColorAllocate(im, clr[i]>>16, clr[i]>>8, clr[i]&0x0000FF);
 
375
  }
 
376
 
 
377
  /* ******************************* */
 
378
  for(i=0, total=0; i<num_points; i++) {
 
379
    total += data[i];
 
380
    if(data[i] > maxval) maxval =  data[i];
 
381
  }
 
382
 
 
383
  center_x = width/2, center_y = height/2;
 
384
 
 
385
  /* ************************* */
 
386
 
 
387
  vmargin = 40; // top (bottom) vertical margin for title (x-labels)
 
388
  hmargin = 70; // left horizontal margin for y-labels
 
389
 
 
390
  base = (int)((width - hmargin) / (1+num_points)); // distance between columns
 
391
 
 
392
  xsize = num_points * base; // x-size of plot
 
393
  ysize = height - (1.5 * vmargin); // y-size of plot
 
394
 
 
395
  /* printf("x-size=%.1f/y-size=%.1f\n", xsize, ysize); */
 
396
  // y labels and grid lines
 
397
  ngrid = 4; // number of grid lines
 
398
 
 
399
  dydat = maxval / ngrid; // data units between grid lines
 
400
  dypix = ysize / (ngrid + 1); // pixels between grid lines
 
401
 
 
402
  for (i = 0; i <= (ngrid + 1); i++) {
 
403
    // height of grid line in units of data
 
404
    ydat = i * dydat;
 
405
    if(snprintf(str, sizeof(str), "%.1f", ydat) < 0)
 
406
      BufferTooShort();
 
407
 
 
408
    // height of grid line in pixels
 
409
    ypos = vmargin/2 + ysize - (int)(i*dypix);
 
410
    txtht = gdFontSmall->h;
 
411
 
 
412
    if(maxval > 0) {
 
413
      if(!formatYlabels) {
 
414
        txtsz = gdFontSmall->w*strlen(str); 
 
415
        xpos = hmargin - txtsz; if(xpos < 1) xpos = 1;
 
416
        gdImageString(im, gdFontSmall, xpos-5, ypos - (int)(txtht/2), str, black);
 
417
      } else {
 
418
        char buf[32];
 
419
        char *theStr = formatThroughput(i * dydat, 0, buf, sizeof(buf));
 
420
 
 
421
        /* traceEvent(CONST_TRACE_INFO, "%u/%s", i * dydat, theStr); */
 
422
 
 
423
        txtsz = gdFontSmall->w*strlen(theStr);
 
424
        xpos = hmargin - txtsz; if(xpos < 1) xpos = 1;
 
425
        gdImageString(im, gdFontSmall, xpos-5, ypos - (int)(txtht/2), theStr, black);   
 
426
      }
 
427
    }
 
428
 
 
429
    if (!(i == 0) && !(i > ngrid)) {
 
430
      gdImageLine(im, hmargin, ypos, hmargin + xsize, ypos, gray);
 
431
    }
 
432
  }
 
433
 
 
434
  // columns and x labels
 
435
  padding = 0; // half of spacing between columns
 
436
  yscale = (float)ysize / ((ngrid+1) * dydat); // pixels per data unit
 
437
 
 
438
  if(maxval > 0) {
 
439
    gdPoint points[5];
 
440
 
 
441
    memset(points, 0, sizeof(points));
 
442
 
 
443
    for (i = 0; i<num_points; i++) {
 
444
      // vertical columns
 
445
      ymax = vmargin/2 + ysize;
 
446
      ymin = ymax - (int)(data[i]*yscale);
 
447
      xmax = hmargin + (i+1)*base - padding;
 
448
      xmin = hmargin + i*base + padding;
 
449
 
 
450
      if(i == 0) {
 
451
        points[0].x = xmin; points[0].y = ymin;
 
452
        points[1].x = xmin; points[1].y = ymax;
 
453
        points[2].x = xmax; points[2].y = ymax;
 
454
        points[3].x = xmax; points[3].y = ymin;
 
455
      } else {
 
456
        points[0].x = points[3].x; points[0].y = points[3].y;
 
457
        points[1].x = points[2].x; points[1].y = points[2].y;
 
458
        points[2].x = xmax; points[2].y = ymax;
 
459
        points[3].x = xmax; points[3].y = ymin;
 
460
      }
 
461
 
 
462
      points[4].x = points[0].x; points[4].y = points[0].y;
 
463
 
 
464
      gdImageFilledPolygon(im, points, 5, colors[0]);
 
465
      gdImageFilledRectangle(im, points[0].x-1, points[0].y-1, points[0].x+1, points[0].y+1, black);
 
466
      gdImageFilledRectangle(im, points[3].x-1, points[3].y-1, points[3].x+1, points[3].y+1, black);
 
467
      gdImageLine(im, points[0].x, points[0].y, points[3].x, points[3].y, black);
 
468
 
 
469
      if((i % 2) == 0) {
 
470
        if(snprintf(str, sizeof(str), "%5s",labels[i]) < 0)
 
471
          BufferTooShort();
 
472
        gdImageStringUp(im, gdFontSmall, points[0].x-gdFontSmall->w, height-2, str, black);
 
473
      }
 
474
 
 
475
      // x labels
 
476
      txtsz = gdFontSmall->w * strlen(labels[i]);
 
477
 
 
478
      xpos = xmin + (int)((base - txtsz) / 2);
 
479
      if(xmin > xpos) xpos = xmin; else xmin = xpos;
 
480
      ypos = ymax + 3; // distance from x axis
 
481
    }
 
482
  }
 
483
 
 
484
  // plot frame
 
485
  gdImageRectangle(im, hmargin, vmargin/2, hmargin + xsize, vmargin/2 + ysize, black);
 
486
 
 
487
  if(xtitle)
 
488
    gdImageString(im, gdFontSmall, (width/2)-(strlen(xtitle)*gdFontSmall->w)/2,
 
489
                  height-gdFontSmall->h-2, xtitle, black);
 
490
 
 
491
  if(ytitle)
 
492
    gdImageString(im, gdFontSmall, 5, 2, ytitle, black);
 
493
 
 
494
  gdImagePng(im, filepointer);
 
495
  gdImageDestroy(im);
 
496
}
 
497
 
 
498
/* ************************ */
 
499
 
 
500
void sendGraphFile(char* fileName, int doNotUnlink) {
 
501
  FILE *fd;
 
502
  int len;
 
503
  char tmpStr[256];
 
504
  int bufSize=sizeof(tmpStr)-1, totLen = 0;
 
505
 
 
506
  if((fd = fopen(fileName, "rb")) != NULL) {
 
507
 
 
508
    for(;;) {
 
509
      len = fread(tmpStr, sizeof(char), bufSize, fd);
 
510
      if(len > 0) {
 
511
                sendStringLen(tmpStr, len);
 
512
                totLen += len;
 
513
          }
 
514
      if(len <= 0) break;
 
515
    }
 
516
    fclose(fd);
 
517
  } else
 
518
    traceEvent(CONST_TRACE_WARNING, "Unable to open file %s - graphic not sent", fileName);
 
519
 
 
520
  if (doNotUnlink == 0) {
 
521
    unlink(fileName);
 
522
  }
 
523
}
 
524
 
 
525
/* ************************ */
 
526
 
 
527
void hostTrafficDistrib(HostTraffic *theHost, short dataSent) {
 
528
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
529
  float p[20];
 
530
  char  *lbl[] = { "", "", "", "", "", "", "", "", "",
 
531
                   "", "", "", "", "", "", "", "", "", "" };
 
532
  int num=0;
 
533
  FILE *fd;
 
534
  TrafficCounter totTraffic;
 
535
  int useFdOpen = 0, idx = 0;
 
536
  ProtocolsList *protoList = myGlobals.ipProtosList;
 
537
 
 
538
  if(dataSent) {
 
539
    totTraffic.value = theHost->tcpSentLoc.value+theHost->tcpSentRem.value+
 
540
      theHost->udpSentLoc.value+theHost->udpSentRem.value+
 
541
      theHost->icmpSent.value+theHost->stpSent.value
 
542
      +theHost->ipxSent.value+theHost->osiSent.value+theHost->dlcSent.value+
 
543
      theHost->arp_rarpSent.value+theHost->decnetSent.value+theHost->appletalkSent.value+
 
544
      theHost->netbiosSent.value+theHost->ipv6Sent.value+theHost->otherSent.value;
 
545
 
 
546
    idx = 0;
 
547
    while(protoList != NULL) {
 
548
      totTraffic.value += theHost->ipProtosList[idx].sent.value;
 
549
      idx++, protoList = protoList->next;
 
550
    }
 
551
  } else {
 
552
    totTraffic.value = theHost->tcpRcvdLoc.value+theHost->tcpRcvdFromRem.value+
 
553
      theHost->udpRcvdLoc.value+theHost->udpRcvdFromRem.value+
 
554
      theHost->icmpRcvd.value+theHost->stpRcvd.value
 
555
      +theHost->ipxRcvd.value+theHost->osiRcvd.value+theHost->dlcRcvd.value+
 
556
      theHost->arp_rarpRcvd.value+theHost->decnetRcvd.value+theHost->appletalkRcvd.value+
 
557
      theHost->netbiosRcvd.value+theHost->ipv6Rcvd.value+theHost->otherRcvd.value;
 
558
 
 
559
    idx = 0;
 
560
    while(protoList != NULL) {
 
561
      totTraffic.value += theHost->ipProtosList[idx].rcvd.value;
 
562
      idx++, protoList = protoList->next;
 
563
    }
 
564
  }
 
565
 
 
566
  if(totTraffic.value > 0) {
 
567
    if(dataSent) {
 
568
      if(theHost->tcpSentLoc.value+theHost->tcpSentRem.value > 0) {
 
569
        p[num] = (float)((100*(theHost->tcpSentLoc.value+
 
570
                               theHost->tcpSentRem.value))/totTraffic.value);
 
571
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "TCP";
 
572
      }
 
573
 
 
574
      if(theHost->udpSentLoc.value+theHost->udpSentRem.value > 0) {
 
575
        p[num] = (float)((100*(theHost->udpSentLoc.value+
 
576
                               theHost->udpSentRem.value))/totTraffic.value);
 
577
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "UDP";
 
578
      }
 
579
 
 
580
      if(theHost->icmpSent.value > 0) {
 
581
        p[num] = (float)((100*theHost->icmpSent.value)/totTraffic.value);
 
582
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "ICMP";
 
583
      }
 
584
 
 
585
      if(theHost->stpSent.value > 0) {
 
586
        p[num] = (float)((100*theHost->stpSent.value)/totTraffic.value);
 
587
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "STP";
 
588
      }
 
589
 
 
590
      if(theHost->ipxSent.value > 0) {
 
591
        p[num] = (float)((100*theHost->ipxSent.value)/totTraffic.value);
 
592
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "IPX";
 
593
      }
 
594
 
 
595
      if(theHost->dlcSent.value > 0) {
 
596
        p[num] = (float)((100*theHost->dlcSent.value)/totTraffic.value);
 
597
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "DLC";
 
598
      }
 
599
 
 
600
      if(theHost->osiSent.value > 0) {
 
601
        p[num] = (float)((100*theHost->osiSent.value)/totTraffic.value);
 
602
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "OSI";
 
603
      }
 
604
 
 
605
      if(theHost->arp_rarpSent.value > 0) {
 
606
        p[num] = (float)((100*theHost->arp_rarpSent.value)/totTraffic.value);
 
607
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "(R)ARP";
 
608
      }
 
609
 
 
610
      if(theHost->decnetSent.value > 0) {
 
611
        p[num] = (float)((100*theHost->decnetSent.value)/totTraffic.value);
 
612
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "DECNET";
 
613
      }
 
614
 
 
615
      if(theHost->appletalkSent.value > 0) {
 
616
        p[num] = (float)((100*theHost->appletalkSent.value)/totTraffic.value);
 
617
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "AppleTalk";
 
618
      }
 
619
 
 
620
      if(theHost->netbiosSent.value > 0) {
 
621
        p[num] = (float)((100*theHost->netbiosSent.value)/totTraffic.value);
 
622
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "NetBios";
 
623
      }
 
624
 
 
625
      if(theHost->ipv6Sent.value > 0) {
 
626
        p[num] = (float)((100*theHost->ipv6Sent.value)/totTraffic.value);
 
627
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "IPv6";
 
628
      }
 
629
 
 
630
      if(theHost->otherSent.value > 0) {
 
631
        p[num] = (float)((100*theHost->otherSent.value)/totTraffic.value);
 
632
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "Other";
 
633
      }
 
634
    } else {
 
635
      if(theHost->tcpRcvdLoc.value+theHost->tcpRcvdFromRem.value > 0) {
 
636
        p[num] = (float)((100*(theHost->tcpRcvdLoc.value+
 
637
                               theHost->tcpRcvdFromRem.value))/totTraffic.value);
 
638
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "TCP";
 
639
      }
 
640
 
 
641
      if(theHost->udpRcvdLoc.value+theHost->udpRcvdFromRem.value > 0) {
 
642
        p[num] = (float)((100*(theHost->udpRcvdLoc.value+
 
643
                               theHost->udpRcvdFromRem.value))/totTraffic.value);
 
644
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "UDP";
 
645
      }
 
646
 
 
647
      if(theHost->icmpRcvd.value > 0) {
 
648
        p[num] = (float)((100*theHost->icmpRcvd.value)/totTraffic.value);
 
649
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "ICMP";
 
650
      }
 
651
 
 
652
      if(theHost->stpRcvd.value > 0) {
 
653
        p[num] = (float)((100*theHost->stpRcvd.value)/totTraffic.value);
 
654
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "STP";
 
655
      }
 
656
 
 
657
      if(theHost->ipxRcvd.value > 0) {
 
658
        p[num] = (float)((100*theHost->ipxRcvd.value)/totTraffic.value);
 
659
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "IPX";
 
660
      }
 
661
 
 
662
      if(theHost->dlcRcvd.value > 0) {
 
663
        p[num] = (float)((100*theHost->dlcRcvd.value)/totTraffic.value);
 
664
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "DLC";
 
665
      }
 
666
 
 
667
      if(theHost->osiRcvd.value > 0) {
 
668
        p[num] = (float)((100*theHost->osiRcvd.value)/totTraffic.value);
 
669
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "OSI";
 
670
      }
 
671
 
 
672
      if(theHost->arp_rarpRcvd.value > 0) {
 
673
        p[num] = (float)((100*theHost->arp_rarpRcvd.value)/totTraffic.value);
 
674
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "(R)ARP";
 
675
      }
 
676
 
 
677
      if(theHost->decnetRcvd.value > 0) {
 
678
        p[num] = (float)((100*theHost->decnetRcvd.value)/totTraffic.value);
 
679
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "DECNET";
 
680
      }
 
681
 
 
682
      if(theHost->appletalkRcvd.value > 0) {
 
683
        p[num] = (float)((100*theHost->appletalkRcvd.value)/totTraffic.value);
 
684
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "AppleTalk";
 
685
      }
 
686
 
 
687
      if(theHost->netbiosRcvd.value > 0) {
 
688
        p[num] = (float)((100*theHost->netbiosRcvd.value)/totTraffic.value);
 
689
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "NetBios";
 
690
      }
 
691
 
 
692
      if(theHost->ipv6Rcvd.value > 0) {
 
693
        p[num] = (float)((100*theHost->ipv6Rcvd.value)/totTraffic.value);
 
694
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "IPv6";
 
695
      }
 
696
 
 
697
      if(theHost->otherRcvd.value > 0) {
 
698
        p[num] = (float)((100*theHost->otherRcvd.value)/totTraffic.value);
 
699
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "Other";
 
700
      }
 
701
    }
 
702
 
 
703
    idx = 0; protoList = myGlobals.ipProtosList;
 
704
    while(protoList != NULL) {
 
705
      if(dataSent) {
 
706
        if(theHost->ipProtosList[idx].sent.value > 0) {
 
707
          p[num] = (float)((100*theHost->ipProtosList[idx].sent.value)/totTraffic.value);
 
708
          if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = protoList->protocolName;
 
709
        }
 
710
      } else {
 
711
        if(theHost->ipProtosList[idx].rcvd.value > 0) {
 
712
          p[num] = (float)((100*theHost->ipProtosList[idx].rcvd.value)/totTraffic.value);
 
713
          if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = protoList->protocolName;
 
714
        }
 
715
      }
 
716
 
 
717
      idx++, protoList = protoList->next;
 
718
    }
 
719
 
 
720
    if(num == 0) {
 
721
      traceEvent(CONST_TRACE_WARNING, "Graph failure (1)");
 
722
      return; /* TODO: this has to be handled better */
 
723
    }
 
724
 
 
725
#ifndef WIN32
 
726
    /* Unices */
 
727
 
 
728
    if(myGlobals.newSock < 0)
 
729
      useFdOpen = 0;
 
730
    else
 
731
      useFdOpen = 1;
 
732
 
 
733
    if(useFdOpen)
 
734
      fd = fdopen(abs(myGlobals.newSock), "ab");
 
735
    else
 
736
      fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
737
#else
 
738
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
739
#endif
 
740
 
 
741
    if(num == 1) p[0] = 100; /* just to be safe */
 
742
 
 
743
    drawPie(300, 250,
 
744
            fd,                 /* open file pointer */
 
745
            num,                /* number of slices */
 
746
            lbl,                /* slice labels */
 
747
            p);                 /* data array */
 
748
    fclose(fd);
 
749
 
 
750
    if(!useFdOpen)
 
751
      sendGraphFile(fileName, 0);
 
752
  }
 
753
}
 
754
 
 
755
/* ************************ */
 
756
 
 
757
void hostFragmentDistrib(HostTraffic *theHost, short dataSent) {
 
758
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
759
  float p[20];
 
760
  char  *lbl[] = { "", "", "", "", "", "", "", "", "",
 
761
                   "", "", "", "", "", "", "", "", "", "" };
 
762
  int num=0;
 
763
  FILE *fd;
 
764
  TrafficCounter totTraffic;
 
765
  int useFdOpen = 0;
 
766
 
 
767
  if(dataSent)
 
768
    totTraffic.value = theHost->tcpFragmentsSent.value+theHost->udpFragmentsSent.value+theHost->icmpFragmentsSent.value;
 
769
  else
 
770
    totTraffic.value = theHost->tcpFragmentsRcvd.value+theHost->udpFragmentsRcvd.value+theHost->icmpFragmentsRcvd.value;
 
771
 
 
772
  if(totTraffic.value > 0) {
 
773
    if(dataSent) {
 
774
      if(theHost->tcpFragmentsSent.value > 0) {
 
775
        p[num] = (float)((100*(theHost->tcpFragmentsSent.value))/totTraffic.value);
 
776
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "TCP";
 
777
      }
 
778
 
 
779
      if(theHost->udpFragmentsSent.value > 0) {
 
780
        p[num] = (float)((100*(theHost->udpFragmentsSent.value))/totTraffic.value);
 
781
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "UDP";
 
782
      }
 
783
 
 
784
      if(theHost->icmpFragmentsSent.value > 0) {
 
785
        p[num] = (float)((100*(theHost->icmpFragmentsSent.value))/totTraffic.value);
 
786
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "ICMP";
 
787
      }
 
788
    } else {
 
789
      if(theHost->tcpFragmentsRcvd.value > 0) {
 
790
        p[num] = (float)((100*(theHost->tcpFragmentsRcvd.value))/totTraffic.value);
 
791
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "TCP";
 
792
      }
 
793
 
 
794
      if(theHost->udpFragmentsRcvd.value > 0) {
 
795
        p[num] = (float)((100*(theHost->udpFragmentsRcvd.value))/totTraffic.value);
 
796
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "UDP";
 
797
      }
 
798
 
 
799
      if(theHost->icmpFragmentsRcvd.value > 0) {
 
800
        p[num] = (float)((100*(theHost->icmpFragmentsRcvd.value))/totTraffic.value);
 
801
        if(p[num] > MIN_SLICE_PERCENTAGE) lbl[num++] = "ICMP";
 
802
      }
 
803
    }
 
804
 
 
805
    if(num == 0) {
 
806
      traceEvent(CONST_TRACE_WARNING, "Graph failure (2)");
 
807
      return; /* TODO: this has to be handled better */
 
808
    }
 
809
 
 
810
#ifndef WIN32
 
811
    /* Unices */
 
812
 
 
813
    if(myGlobals.newSock < 0)
 
814
      useFdOpen = 0;
 
815
    else
 
816
      useFdOpen = 1;
 
817
 
 
818
    if(useFdOpen)
 
819
      fd = fdopen(abs(myGlobals.newSock), "ab");
 
820
    else
 
821
      fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
822
#else
 
823
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
824
#endif
 
825
 
 
826
    if(num == 1) p[0] = 100; /* just to be safe */
 
827
    drawPie(400, 250,
 
828
            fd,                 /* open file pointer */
 
829
            num,                /* number of slices */
 
830
            lbl,                /* slice labels */
 
831
            p);                 /* data array */
 
832
 
 
833
    fclose(fd);
 
834
 
 
835
    if(!useFdOpen)
 
836
      sendGraphFile(fileName, 0);
 
837
  }
 
838
}
 
839
 
 
840
/* ************************ */
 
841
 
 
842
void hostTimeTrafficDistribution(HostTraffic *theHost, short dataSent) {
 
843
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
844
  float p[24];
 
845
  char  *lbl[] = { "", "", "", "", "", "", "", "", "",
 
846
                   "", "", "", "", "", "", "", "", "",
 
847
                   "", "", "", "", "", "", "", "", "", "" };
 
848
  int num=0, i;
 
849
  FILE *fd;
 
850
  int useFdOpen = 0;
 
851
 
 
852
  for(i=0; i<24; i++) {
 
853
    TrafficCounter traf;
 
854
 
 
855
    if(dataSent)
 
856
      traf.value = theHost->trafficDistribution->last24HoursBytesSent[i].value;
 
857
    else
 
858
      traf.value = theHost->trafficDistribution->last24HoursBytesRcvd[i].value;
 
859
 
 
860
    if(traf.value > 0) {
 
861
      p[num] = traf.value;
 
862
      switch(i) {
 
863
      case 0:
 
864
        lbl[num++] = "12PM-1AM";
 
865
        break;
 
866
      case 1:
 
867
        lbl[num++] = "1-2AM";
 
868
        break;
 
869
      case 2:
 
870
        lbl[num++] = "2-3AM";
 
871
        break;
 
872
      case 3:
 
873
        lbl[num++] = "3-4AM";
 
874
        break;
 
875
      case 4:
 
876
        lbl[num++] = "4-5AM";
 
877
        break;
 
878
      case 5:
 
879
        lbl[num++] = "5-6AM";
 
880
        break;
 
881
      case 6:
 
882
        lbl[num++] = "6-7AM";
 
883
        break;
 
884
      case 7:
 
885
        lbl[num++] = "7-8AM";
 
886
        break;
 
887
      case 8:
 
888
        lbl[num++] = "8-9AM";
 
889
        break;
 
890
      case 9:
 
891
        lbl[num++] = "9-10AM";
 
892
        break;
 
893
      case 10:
 
894
        lbl[num++] = "10-11AM";
 
895
        break;
 
896
      case 11:
 
897
        lbl[num++] = "11-12AM";
 
898
        break;
 
899
      case 12:
 
900
        lbl[num++] = "12AM-1PM";
 
901
        break;
 
902
      case 13:
 
903
        lbl[num++] = "1-2PM";
 
904
        break;
 
905
      case 14:
 
906
        lbl[num++] = "2-3PM";
 
907
        break;
 
908
      case 15:
 
909
        lbl[num++] = "3-4PM";
 
910
        break;
 
911
      case 16:
 
912
        lbl[num++] = "4-5PM";
 
913
        break;
 
914
      case 17:
 
915
        lbl[num++] = "5-6PM";
 
916
        break;
 
917
      case 18:
 
918
        lbl[num++] = "6-7PM";
 
919
        break;
 
920
      case 19:
 
921
        lbl[num++] = "7-8PM";
 
922
        break;
 
923
      case 20:
 
924
        lbl[num++] = "8-9PM";
 
925
        break;
 
926
      case 21:
 
927
        lbl[num++] = "9-10PM";
 
928
        break;
 
929
      case 22:
 
930
        lbl[num++] = "10-11PM";
 
931
        break;
 
932
      case 23:
 
933
        lbl[num++] = "11-12PM";
 
934
        break;
 
935
      }
 
936
    }
 
937
  }
 
938
 
 
939
  if(num == 0) {
 
940
    traceEvent(CONST_TRACE_WARNING, "Graph failure (2)");
 
941
    return; /* TODO: this has to be handled better */
 
942
  }
 
943
  
 
944
#ifndef WIN32
 
945
  /* Unices */
 
946
 
 
947
  if(myGlobals.newSock < 0)
 
948
    useFdOpen = 0;
 
949
  else
 
950
    useFdOpen = 1;
 
951
 
 
952
  if(useFdOpen)
 
953
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
954
  else
 
955
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
956
#else
 
957
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
958
#endif
 
959
 
 
960
  if(num == 1) p[0] = 100; /* just to be safe */
 
961
  drawPie(300, 250,
 
962
          fd,           /* open file pointer */
 
963
          num,          /* number of slices */
 
964
          lbl,          /* slice labels */
 
965
          p);           /* data array */
 
966
 
 
967
  fclose(fd);
 
968
 
 
969
  if(!useFdOpen)
 
970
    sendGraphFile(fileName, 0);
 
971
}
 
972
 
 
973
/* ************************ */
 
974
 
 
975
void hostTotalFragmentDistrib(HostTraffic *theHost, short dataSent) {
 
976
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
977
  float p[20];
 
978
  char  *lbl[] = { "", "", "", "", "", "", "", "", "",
 
979
                   "", "", "", "", "", "", "", "", "", "" };
 
980
  int num=0;
 
981
  FILE *fd;
 
982
  TrafficCounter totFragmentedTraffic, totTraffic;
 
983
  int useFdOpen = 0;
 
984
 
 
985
  if(dataSent) {
 
986
    totTraffic.value = theHost->ipBytesSent.value;
 
987
    totFragmentedTraffic.value = theHost->tcpFragmentsSent.value+theHost->udpFragmentsSent.value
 
988
      +theHost->icmpFragmentsSent.value;
 
989
  } else {
 
990
    totTraffic.value = theHost->ipBytesRcvd.value;
 
991
    totFragmentedTraffic.value = theHost->tcpFragmentsRcvd.value+theHost->udpFragmentsRcvd.value
 
992
      +theHost->icmpFragmentsRcvd.value;
 
993
  }
 
994
 
 
995
  if(totTraffic.value > 0) {
 
996
    p[num] = (float)((100*totFragmentedTraffic.value)/totTraffic.value);
 
997
    lbl[num++] = "Frag";
 
998
 
 
999
    p[num] = 100-((float)(100*totFragmentedTraffic.value)/totTraffic.value);
 
1000
    if(p[num] > 0) { lbl[num++] = "Non Frag"; }
 
1001
 
 
1002
    if(num == 0) {
 
1003
      traceEvent(CONST_TRACE_WARNING, "Graph failure (3)");
 
1004
      return; /* TODO: this has to be handled better */
 
1005
    }
 
1006
 
 
1007
#ifndef WIN32
 
1008
    /* Unices */
 
1009
 
 
1010
    if(myGlobals.newSock < 0)
 
1011
      useFdOpen = 0;
 
1012
    else
 
1013
      useFdOpen = 1;
 
1014
 
 
1015
    if(useFdOpen)
 
1016
      fd = fdopen(abs(myGlobals.newSock), "ab");
 
1017
    else
 
1018
      fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1019
#else
 
1020
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1021
#endif
 
1022
 
 
1023
    if(num == 1) p[0] = 100; /* just to be safe */
 
1024
    drawPie(400, 250,
 
1025
            fd,                 /* open file pointer */
 
1026
            num,                /* number of slices */
 
1027
            lbl,                /* slice labels */
 
1028
            p);                 /* data array */
 
1029
 
 
1030
    fclose(fd);
 
1031
 
 
1032
    if(!useFdOpen)
 
1033
      sendGraphFile(fileName, 0);
 
1034
  }
 
1035
}
 
1036
 
 
1037
/* ************************ */
 
1038
 
 
1039
void hostIPTrafficDistrib(HostTraffic *theHost, short dataSent) {
 
1040
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1041
  float p[MAX_NUM_PROTOS];
 
1042
  char  *lbl[] = { "", "", "", "", "", "", "", "", "",
 
1043
                   "", "", "", "", "", "", "", "", "", "" };
 
1044
  int i, num=0;
 
1045
  FILE *fd;
 
1046
  TrafficCounter traffic, totalIPTraffic, diffTraffic;
 
1047
  int useFdOpen = 0;
 
1048
 
 
1049
  if(theHost->protoIPTrafficInfos == NULL) {
 
1050
    traceEvent(CONST_TRACE_WARNING, "Graph failure (5)");
 
1051
    return;
 
1052
  }
 
1053
 
 
1054
  totalIPTraffic.value = 0;
 
1055
  diffTraffic.value = 0;
 
1056
 
 
1057
  if(dataSent)
 
1058
    totalIPTraffic.value = theHost->ipBytesSent.value;
 
1059
  else
 
1060
    totalIPTraffic.value = theHost->ipBytesRcvd.value;
 
1061
 
 
1062
  if(totalIPTraffic.value > 0) {
 
1063
    for(i=0; i<myGlobals.numIpProtosToMonitor; i++) {
 
1064
      if(dataSent)
 
1065
        traffic.value = theHost->protoIPTrafficInfos[i].sentLoc.value+theHost->protoIPTrafficInfos[i].sentRem.value;
 
1066
      else
 
1067
        traffic.value = theHost->protoIPTrafficInfos[i].rcvdLoc.value+theHost->protoIPTrafficInfos[i].rcvdFromRem.value;
 
1068
 
 
1069
      if(traffic.value > 0) {
 
1070
        p[num] = (float)((100*traffic.value)/totalIPTraffic.value);
 
1071
        diffTraffic.value += traffic.value;
 
1072
        lbl[num++] = myGlobals.protoIPTrafficInfos[i];
 
1073
      }
 
1074
 
 
1075
      if(num >= MAX_NUM_PROTOS) break; /* Too much stuff */
 
1076
    }
 
1077
  }
 
1078
 
 
1079
  if(num == 0) {
 
1080
    p[num] = 1;
 
1081
    lbl[num++] = "Other";
 
1082
  } else {
 
1083
    if(diffTraffic.value < totalIPTraffic.value) {
 
1084
      diffTraffic.value = totalIPTraffic.value - diffTraffic.value;
 
1085
      p[num] = (float)((100*diffTraffic.value)/totalIPTraffic.value);
 
1086
      lbl[num++] = "Other";
 
1087
    }
 
1088
  }
 
1089
 
 
1090
#ifndef WIN32
 
1091
  /* Unices */
 
1092
 
 
1093
  if(myGlobals.newSock < 0)
 
1094
    useFdOpen = 0;
 
1095
  else
 
1096
    useFdOpen = 1;
 
1097
 
 
1098
  if(useFdOpen)
 
1099
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1100
  else
 
1101
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1102
#else
 
1103
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1104
#endif
 
1105
 
 
1106
  if(num == 1) p[0] = 100;
 
1107
 
 
1108
  if(num == 1) p[0] = 100; /* just to be safe */
 
1109
  drawPie(300, 250,
 
1110
          fd,                   /* open file pointer */
 
1111
          num,                  /* number of slices */
 
1112
          lbl,                  /* slice labels */
 
1113
          p);                   /* data array */
 
1114
 
 
1115
  fclose(fd);
 
1116
 
 
1117
  if(!useFdOpen)
 
1118
    sendGraphFile(fileName, 0);
 
1119
}
 
1120
 
 
1121
/* ********************************** */
 
1122
 
 
1123
void pktSizeDistribPie(void) {
 
1124
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1125
  float p[7];
 
1126
  char  *lbl[] = { "", "", "", "", "", "", "" };
 
1127
  int num=0;
 
1128
  FILE *fd;
 
1129
  int useFdOpen = 0;
 
1130
 
 
1131
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo64.value > 0) {
 
1132
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo64.value)/
 
1133
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1134
    lbl[num++] = "< 64";
 
1135
  };
 
1136
 
 
1137
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo128.value > 0) {
 
1138
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo128.value)/
 
1139
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1140
    lbl[num++] = "< 128";
 
1141
  };
 
1142
 
 
1143
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo256.value > 0) {
 
1144
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo256.value)/
 
1145
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1146
    lbl[num++] = "< 256";
 
1147
  };
 
1148
 
 
1149
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo512.value > 0) {
 
1150
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo512.value)/
 
1151
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1152
    lbl[num++] = "< 512";
 
1153
  };
 
1154
 
 
1155
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo1024.value > 0) {
 
1156
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo1024.value)/
 
1157
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1158
    lbl[num++] = "< 1024";
 
1159
  };
 
1160
 
 
1161
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo1518.value > 0) {
 
1162
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.upTo1518.value)/
 
1163
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1164
    lbl[num++] = "< 1518";
 
1165
  };
 
1166
 
 
1167
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.above1518.value > 0) {
 
1168
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktStats.above1518.value)/
 
1169
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1170
    lbl[num++] = "> 1518";
 
1171
  };
 
1172
 
 
1173
 
 
1174
#ifndef WIN32
 
1175
  /* Unices */
 
1176
 
 
1177
  if(myGlobals.newSock < 0)
 
1178
    useFdOpen = 0;
 
1179
  else
 
1180
    useFdOpen = 1;
 
1181
 
 
1182
  if(useFdOpen)
 
1183
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1184
  else
 
1185
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1186
#else
 
1187
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1188
#endif
 
1189
 
 
1190
  if(num == 1) p[0] = 100; /* just to be safe */
 
1191
  drawPie(400, 250,
 
1192
          fd,                   /* open file pointer */
 
1193
          num,                  /* number of slices */
 
1194
          lbl,                  /* slice labels */
 
1195
          p);                   /* data array */
 
1196
 
 
1197
  fclose(fd);
 
1198
 
 
1199
  if(!useFdOpen)
 
1200
    sendGraphFile(fileName, 0);
 
1201
}
 
1202
 
 
1203
/* ********************************** */
 
1204
 
 
1205
void pktTTLDistribPie(void) {
 
1206
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1207
  float p[8];
 
1208
  char  *lbl[] = { "", "", "", "", "", "", "" };
 
1209
  int num=0;
 
1210
  FILE *fd;
 
1211
  int useFdOpen = 0;
 
1212
 
 
1213
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo32.value > 0) {
 
1214
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo32.value)/
 
1215
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1216
    lbl[num++] = "< 32";
 
1217
  };
 
1218
 
 
1219
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo64.value > 0) {
 
1220
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo64.value)/
 
1221
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1222
    lbl[num++] = "< 64";
 
1223
  };
 
1224
 
 
1225
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo96.value > 0) {
 
1226
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo96.value)/
 
1227
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1228
    lbl[num++] = "< 96";
 
1229
  };
 
1230
 
 
1231
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo128.value > 0) {
 
1232
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo128.value)/
 
1233
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1234
    lbl[num++] = "< 128";
 
1235
  };
 
1236
 
 
1237
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo160.value > 0) {
 
1238
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo160.value)/
 
1239
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1240
    lbl[num++] = "< 160";
 
1241
  };
 
1242
 
 
1243
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo192.value > 0) {
 
1244
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo192.value)/
 
1245
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1246
    lbl[num++] = "< 192";
 
1247
  };
 
1248
 
 
1249
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo224.value > 0) {
 
1250
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo224.value)/
 
1251
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1252
    lbl[num++] = "< 224";
 
1253
  };
 
1254
 
 
1255
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo255.value > 0) {
 
1256
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdPktTTLStats.upTo255.value)/
 
1257
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ipPkts.value;
 
1258
    lbl[num++] = "<= 255";
 
1259
  };
 
1260
 
 
1261
#ifndef WIN32
 
1262
  /* Unices */
 
1263
 
 
1264
  if(myGlobals.newSock < 0)
 
1265
    useFdOpen = 0;
 
1266
  else
 
1267
    useFdOpen = 1;
 
1268
 
 
1269
  if(useFdOpen)
 
1270
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1271
  else
 
1272
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1273
#else
 
1274
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1275
#endif
 
1276
 
 
1277
  if(num == 1) p[0] = 100; /* just to be safe */
 
1278
  drawPie(400, 250,
 
1279
          fd,                   /* open file pointer */
 
1280
          num,                  /* number of slices */
 
1281
          lbl,                  /* slice labels */
 
1282
          p);                   /* data array */
 
1283
 
 
1284
  fclose(fd);
 
1285
 
 
1286
  if(!useFdOpen)
 
1287
    sendGraphFile(fileName, 0);
 
1288
}
 
1289
 
 
1290
/* ************************ */
 
1291
 
 
1292
void ipProtoDistribPie(void) {
 
1293
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1294
  float p[3];
 
1295
  char  *lbl[] = { "Loc", "Rem->Loc", "Loc->Rem" };
 
1296
  int num=0;
 
1297
  FILE *fd;
 
1298
  int useFdOpen = 0;
 
1299
 
 
1300
  p[num] = (float)(myGlobals.device[myGlobals.actualReportDeviceId].tcpGlobalTrafficStats.local.value+
 
1301
                   myGlobals.device[myGlobals.actualReportDeviceId].udpGlobalTrafficStats.local.value)/1024;
 
1302
  if(p[num] > 0) {
 
1303
    lbl[num++] = "Loc";
 
1304
  }
 
1305
 
 
1306
  p[num] = (float)(myGlobals.device[myGlobals.actualReportDeviceId].tcpGlobalTrafficStats.remote2local.value+
 
1307
                   myGlobals.device[myGlobals.actualReportDeviceId].udpGlobalTrafficStats.remote2local.value)/1024;
 
1308
  if(p[num] > 0) {
 
1309
    lbl[num++] = "Rem->Loc";
 
1310
  }
 
1311
 
 
1312
  p[num] = (float)(myGlobals.device[myGlobals.actualReportDeviceId].tcpGlobalTrafficStats.local2remote.value+
 
1313
                   myGlobals.device[myGlobals.actualReportDeviceId].udpGlobalTrafficStats.local2remote.value)/1024;
 
1314
  if(p[num] > 0) {
 
1315
    lbl[num++] = "Loc->Rem";
 
1316
  }
 
1317
 
 
1318
#ifndef WIN32
 
1319
  /* Unices */
 
1320
 
 
1321
  if(myGlobals.newSock < 0)
 
1322
    useFdOpen = 0;
 
1323
  else
 
1324
    useFdOpen = 1;
 
1325
 
 
1326
  if(useFdOpen)
 
1327
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1328
  else
 
1329
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1330
#else
 
1331
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1332
#endif
 
1333
 
 
1334
  if(num == 1) p[0] = 100; /* just to be safe */
 
1335
  drawPie(400, 250,
 
1336
          fd,                   /* open file pointer */
 
1337
          num,                  /* number of slices */
 
1338
          lbl,                  /* slice labels */
 
1339
          p);                   /* data array */
 
1340
 
 
1341
  fclose(fd);
 
1342
 
 
1343
  if(!useFdOpen)
 
1344
    sendGraphFile(fileName, 0);
 
1345
}
 
1346
 
 
1347
/* ************************ */
 
1348
 
 
1349
void interfaceTrafficPie(void) {
 
1350
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1351
  float p[MAX_NUM_DEVICES];
 
1352
  int i;
 
1353
  FILE *fd;
 
1354
  TrafficCounter totPkts;
 
1355
  char  *lbl[MAX_NUM_DEVICES];
 
1356
  int myDevices=0;
 
1357
  int useFdOpen = 0;
 
1358
 
 
1359
  totPkts.value = 0;
 
1360
 
 
1361
  for(i=0; i<myGlobals.numDevices; i++) {
 
1362
    if(myGlobals.device[i].pcapPtr && (!myGlobals.device[i].virtualDevice)) {
 
1363
      p[i] = (float)myGlobals.device[i].ethernetPkts.value;
 
1364
      totPkts.value += myGlobals.device[i].ethernetPkts.value;
 
1365
    } else
 
1366
      p[i] = 0.0;
 
1367
  }
 
1368
 
 
1369
  if(totPkts.value == 0)
 
1370
    totPkts.value++;
 
1371
 
 
1372
  for(i=0; i<myGlobals.numDevices; i++) {
 
1373
    if((!myGlobals.device[i].virtualDevice) && (p[i] > 0))  {
 
1374
      p[myDevices]   = 100*(((float)p[i])/totPkts.value);
 
1375
      lbl[myDevices] = myGlobals.device[i].name;
 
1376
      myDevices++;
 
1377
    }
 
1378
  }
 
1379
 
 
1380
#ifndef WIN32
 
1381
  /* Unices */
 
1382
 
 
1383
  if(myGlobals.newSock < 0)
 
1384
    useFdOpen = 0;
 
1385
  else
 
1386
    useFdOpen = 1;
 
1387
 
 
1388
  if(useFdOpen)
 
1389
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1390
  else
 
1391
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1392
#else
 
1393
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1394
#endif
 
1395
 
 
1396
  if(myDevices == 1) p[0] = 100; /* just to be safe */
 
1397
  drawPie(400, 250,
 
1398
          fd,           /* open file pointer */
 
1399
          myDevices,    /* number of slices */
 
1400
          lbl,          /* slice labels */
 
1401
          p);           /* data array */
 
1402
 
 
1403
  fclose(fd);
 
1404
 
 
1405
  if(!useFdOpen)
 
1406
    sendGraphFile(fileName, 0);
 
1407
}
 
1408
 
 
1409
/* ************************ */
 
1410
 
 
1411
void pktCastDistribPie(void) {
 
1412
  char fileName[64] = "/tmp/graph-XXXXXX";
 
1413
  float p[3];
 
1414
  char  *lbl[] = { "", "", "" };
 
1415
  int num=0, useFdOpen = 0;
 
1416
  FILE *fd;
 
1417
  TrafficCounter unicastPkts;
 
1418
 
 
1419
  unicastPkts.value = myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value
 
1420
    - myGlobals.device[myGlobals.actualReportDeviceId].broadcastPkts.value
 
1421
    - myGlobals.device[myGlobals.actualReportDeviceId].multicastPkts.value;
 
1422
 
 
1423
  if(unicastPkts.value > 0) {
 
1424
    p[num] = (float)(100*unicastPkts.value)/(float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1425
    lbl[num++] = "Unicast";
 
1426
  };
 
1427
 
 
1428
  if(myGlobals.device[myGlobals.actualReportDeviceId].broadcastPkts.value > 0) {
 
1429
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].broadcastPkts.value)/
 
1430
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1431
    lbl[num++] = "Broadcast";
 
1432
  };
 
1433
 
 
1434
  if(myGlobals.device[myGlobals.actualReportDeviceId].multicastPkts.value > 0) {
 
1435
    int i;
 
1436
 
 
1437
    p[num] = 100;
 
1438
    for(i=0; i<num; i++)
 
1439
      p[num] -= p[i];
 
1440
 
 
1441
    if(p[num] < 0) p[num] = 0;
 
1442
    lbl[num++] = "Multicast";
 
1443
  };
 
1444
 
 
1445
#ifndef WIN32
 
1446
  /* Unices */
 
1447
 
 
1448
  if(myGlobals.newSock < 0)
 
1449
    useFdOpen = 0;
 
1450
  else
 
1451
    useFdOpen = 1;
 
1452
 
 
1453
  if(useFdOpen)
 
1454
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1455
  else
 
1456
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1457
#else
 
1458
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1459
#endif
 
1460
 
 
1461
  if(num == 1) p[0] = 100;  /* just to be safe */
 
1462
  drawPie(400, 250,
 
1463
          fd,                   /* open file pointer */
 
1464
          num,                  /* number of slices */
 
1465
          lbl,                  /* slice labels */
 
1466
          p);                   /* data array */
 
1467
 
 
1468
  fclose(fd);
 
1469
 
 
1470
  if(!useFdOpen)
 
1471
    sendGraphFile(fileName, 0);
 
1472
}
 
1473
 
 
1474
/* ************************ */
 
1475
 
 
1476
void drawTrafficPie(void) {
 
1477
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1478
  TrafficCounter ip;
 
1479
  float p[2];
 
1480
  char  *lbl[] = { "IP", "Non IP" };
 
1481
  int num=0;
 
1482
  FILE *fd;
 
1483
  int useFdOpen = 0;
 
1484
 
 
1485
  if(myGlobals.device[myGlobals.actualReportDeviceId].ethernetBytes.value == 0) return;
 
1486
 
 
1487
  ip.value = myGlobals.device[myGlobals.actualReportDeviceId].ipBytes.value;
 
1488
 
 
1489
  p[0] = ip.value*100/myGlobals.device[myGlobals.actualReportDeviceId].ethernetBytes.value; num++;
 
1490
  p[1] = 100-p[0];
 
1491
 
 
1492
  if(p[1] > 0)
 
1493
    num++;
 
1494
 
 
1495
#ifndef WIN32
 
1496
  /* Unices */
 
1497
 
 
1498
  if(myGlobals.newSock < 0)
 
1499
    useFdOpen = 0;
 
1500
  else
 
1501
    useFdOpen = 1;
 
1502
 
 
1503
  if(useFdOpen)
 
1504
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1505
  else
 
1506
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1507
#else
 
1508
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1509
#endif
 
1510
 
 
1511
  if(num == 1) p[0] = 100; /* just to be safe */
 
1512
  drawPie(400, 250,
 
1513
          fd,                   /* open file pointer */
 
1514
          num,                  /* number of slices */
 
1515
          lbl,                  /* slice labels */
 
1516
          p);                   /* data array */
 
1517
 
 
1518
  fclose(fd);
 
1519
 
 
1520
  if(!useFdOpen)
 
1521
    sendGraphFile(fileName, 0);
 
1522
}
 
1523
 
 
1524
/* ************************ */
 
1525
 
 
1526
void drawThptGraph(int sortedColumn) {
 
1527
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1528
  int i, len;
 
1529
  char  labels[60][32];
 
1530
  char  *lbls[60];
 
1531
  FILE *fd;
 
1532
  time_t tmpTime;
 
1533
  float graphData[60];
 
1534
  struct tm t;
 
1535
  int useFdOpen = 0;
 
1536
 
 
1537
  memset(graphData, 0, sizeof(graphData));
 
1538
 
 
1539
#ifndef WIN32
 
1540
  /* Unices */
 
1541
 
 
1542
  if(myGlobals.newSock < 0)
 
1543
    useFdOpen = 0;
 
1544
  else
 
1545
    useFdOpen = 1;
 
1546
 
 
1547
  if(useFdOpen)
 
1548
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1549
  else
 
1550
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1551
#else
 
1552
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1553
#endif
 
1554
 
 
1555
  switch(sortedColumn) {
 
1556
  case 1: /* 60 Minutes */
 
1557
    for(i=0; i<60; i++) {
 
1558
      lbls[59-i] = labels[i];
 
1559
      labels[i][0] = '\0';
 
1560
    }
 
1561
 
 
1562
    len = myGlobals.device[myGlobals.actualReportDeviceId].numThptSamples;
 
1563
    if(len > 60) len = 60;
 
1564
    for(i=0; i<len; i++) {
 
1565
      tmpTime = myGlobals.actTime-i*60;
 
1566
      strftime(labels[i], 32, CONST_TOD_NOSEC_TIMESPEC, localtime_r(&tmpTime, &t));
 
1567
    }
 
1568
 
 
1569
    for(i=0; i<len; i++)
 
1570
      graphData[59-i] = myGlobals.device[myGlobals.actualReportDeviceId].last60MinutesThpt[i].trafficValue;
 
1571
 
 
1572
    drawArea(600, 300,            /* width, height           */
 
1573
             fd,                  /* open FILE pointer       */
 
1574
             60,                  /* num points per data set */
 
1575
             (char**)lbls,        /* X labels array of char* */
 
1576
             graphData, NULL,     /* dataset 1   */
 
1577
             "Throughput", 1);
 
1578
    break;
 
1579
  case 2: /* 24 Hours */
 
1580
    for(i=0; i<24; i++) {
 
1581
      lbls[23-i] = labels[i];
 
1582
      labels[i][0] = '\0';
 
1583
    }
 
1584
 
 
1585
    len = myGlobals.device[myGlobals.actualReportDeviceId].numThptSamples/60;
 
1586
    if(len > 24) len = 24;
 
1587
    for(i=0; i<len; i++) {
 
1588
      tmpTime = myGlobals.actTime-((i+1)*60*60);
 
1589
      strftime(labels[i], 32, CONST_THPTLABEL_TIMESPEC, localtime_r(&tmpTime, &t));
 
1590
    }
 
1591
 
 
1592
    for(i=0; i<len; i++)
 
1593
      graphData[23-i] = myGlobals.device[myGlobals.actualReportDeviceId].last24HoursThpt[i].trafficValue;
 
1594
 
 
1595
    drawArea(600, 300,      /* width, height           */
 
1596
             fd,            /* open FILE pointer       */
 
1597
             24,            /* num points per data set */
 
1598
             lbls,          /* X labels array of char* */
 
1599
             graphData, NULL,    /* dataset 1   */
 
1600
             "Throughput", 1);
 
1601
    break;
 
1602
  case 3: /* 30 Days */
 
1603
    for(i=0; i<30; i++) {
 
1604
      lbls[29-i] = labels[i];
 
1605
      labels[i][0] = '\0';
 
1606
    }
 
1607
 
 
1608
    len = myGlobals.device[myGlobals.actualReportDeviceId].numThptSamples/(24*60);
 
1609
    if(len > 30) len = 30;
 
1610
    for(i=0; i<len; i++) {
 
1611
      tmpTime = myGlobals.actTime-((i+1)*(60*60*24));
 
1612
      strftime(labels[i], 32, CONST_THPTLABEL_TIMESPEC, localtime_r(&tmpTime, &t));
 
1613
    }
 
1614
 
 
1615
    for(i=0; i<len; i++)
 
1616
      graphData[29-i] = myGlobals.device[myGlobals.actualReportDeviceId].last30daysThpt[i];
 
1617
 
 
1618
    drawArea(600, 300,          /* width, height           */
 
1619
             fd,                /* open FILE pointer       */
 
1620
             30,                /* num points per data set */
 
1621
             lbls,              /* X labels array of char* */
 
1622
             graphData, NULL,
 
1623
             "Throughput", 1);
 
1624
    break;
 
1625
  }
 
1626
 
 
1627
  fclose(fd);
 
1628
 
 
1629
  if(!useFdOpen)
 
1630
    sendGraphFile(fileName, 0);
 
1631
}
 
1632
 
 
1633
/* ************************ */
 
1634
 
 
1635
void drawGlobalProtoDistribution(void) {
 
1636
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1637
  TrafficCounter ip;
 
1638
  float p[256]; /* Fix courtesy of Andreas Pfaller <apfaller@yahoo.com.au> */
 
1639
  char  *lbl[16];
 
1640
  FILE *fd;
 
1641
  int idx = 0;
 
1642
  int useFdOpen = 0;
 
1643
 
 
1644
  ip.value = myGlobals.device[myGlobals.actualReportDeviceId].ipBytes.value;
 
1645
 
 
1646
  if(myGlobals.device[myGlobals.actualReportDeviceId].tcpBytes.value > 0) {
 
1647
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].tcpBytes.value; lbl[idx] = "TCP";  idx++; }
 
1648
  if(myGlobals.device[myGlobals.actualReportDeviceId].udpBytes.value > 0) {
 
1649
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].udpBytes.value; lbl[idx] = "UDP"; idx++; }
 
1650
  if(myGlobals.device[myGlobals.actualReportDeviceId].icmpBytes.value > 0) {
 
1651
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].icmpBytes.value; lbl[idx] = "ICMP"; idx++; }
 
1652
  if(myGlobals.device[myGlobals.actualReportDeviceId].otherIpBytes.value > 0) {
 
1653
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].otherIpBytes.value; lbl[idx] = "Other IP"; idx++; }
 
1654
  if(myGlobals.device[myGlobals.actualReportDeviceId].arpRarpBytes.value > 0) {
 
1655
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].arpRarpBytes.value; lbl[idx] = "(R)ARP"; idx++; }
 
1656
  if(myGlobals.device[myGlobals.actualReportDeviceId].dlcBytes.value > 0) {
 
1657
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].dlcBytes.value; lbl[idx] = "DLC"; idx++; }
 
1658
  if(myGlobals.device[myGlobals.actualReportDeviceId].ipxBytes.value > 0) {
 
1659
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].ipxBytes.value; lbl[idx] = "IPX"; idx++; }
 
1660
  if(myGlobals.device[myGlobals.actualReportDeviceId].decnetBytes.value > 0) {
 
1661
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].decnetBytes.value;lbl[idx] = "Decnet";  idx++; }
 
1662
  if(myGlobals.device[myGlobals.actualReportDeviceId].atalkBytes.value > 0) {
 
1663
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].atalkBytes.value; lbl[idx] = "AppleTalk"; idx++; }
 
1664
  if(myGlobals.device[myGlobals.actualReportDeviceId].netbiosBytes.value > 0) {
 
1665
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].netbiosBytes.value; lbl[idx] = "NetBios"; idx++; }
 
1666
  if(myGlobals.device[myGlobals.actualReportDeviceId].osiBytes.value > 0) {
 
1667
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].osiBytes.value; lbl[idx] = "OSI"; idx++; }
 
1668
  if(myGlobals.device[myGlobals.actualReportDeviceId].ipv6Bytes.value > 0) {
 
1669
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].ipv6Bytes.value; lbl[idx] = "IPv6"; idx++; }
 
1670
  if(myGlobals.device[myGlobals.actualReportDeviceId].stpBytes.value > 0) {
 
1671
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].stpBytes.value; lbl[idx] = "STP"; idx++; }
 
1672
  if(myGlobals.device[myGlobals.actualReportDeviceId].otherBytes.value > 0) {
 
1673
    p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].otherBytes.value; lbl[idx] = "Other"; idx++; }
 
1674
 
 
1675
 
 
1676
  {
 
1677
    ProtocolsList *protoList = myGlobals.ipProtosList;
 
1678
    int idx1 = 0;
 
1679
 
 
1680
    while(protoList != NULL) {
 
1681
 
 
1682
      if(myGlobals.device[myGlobals.actualReportDeviceId].ipProtosList[idx1].value > 0) {
 
1683
        p[idx] = myGlobals.device[myGlobals.actualReportDeviceId].ipProtosList[idx1].value;
 
1684
        lbl[idx] = protoList->protocolName; idx++;
 
1685
      }
 
1686
 
 
1687
      idx1++, protoList = protoList->next;
 
1688
    }
 
1689
  }
 
1690
 
 
1691
 
 
1692
#ifndef WIN32
 
1693
  /* Unices */
 
1694
 
 
1695
  if(myGlobals.newSock < 0)
 
1696
    useFdOpen = 0;
 
1697
  else
 
1698
    useFdOpen = 1;
 
1699
 
 
1700
  if(useFdOpen)
 
1701
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1702
  else
 
1703
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1704
#else
 
1705
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1706
#endif
 
1707
 
 
1708
  drawBar(600, 250,     /* width/height */
 
1709
          fd,           /* open file pointer */
 
1710
          idx,          /* number of slices */
 
1711
          lbl,          /* slice labels */
 
1712
          p);           /* data array */
 
1713
 
 
1714
  fclose(fd);
 
1715
 
 
1716
  if(!useFdOpen)
 
1717
    sendGraphFile(fileName, 0);
 
1718
}
 
1719
 
 
1720
/* ************************ */
 
1721
 
 
1722
void drawGlobalIpProtoDistribution(void) {
 
1723
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1724
  int i, idx=0, idx1 = 0, maxNumDisplayProto = 13;
 
1725
  float p[256];
 
1726
  char *lbl[256];
 
1727
  FILE *fd;
 
1728
  int useFdOpen = 0;
 
1729
  ProtocolsList *protoList = myGlobals.ipProtosList;
 
1730
  float total, partialTotal = 0;
 
1731
 
 
1732
  total = (float)myGlobals.device[myGlobals.actualReportDeviceId].ipBytes.value;
 
1733
 
 
1734
  while(protoList != NULL) {
 
1735
    if(total > (float)myGlobals.device[myGlobals.actualReportDeviceId].ipProtosList[idx1].value)
 
1736
      total -= (float)myGlobals.device[myGlobals.actualReportDeviceId].ipProtosList[idx1].value;
 
1737
    else
 
1738
      total = 0;
 
1739
 
 
1740
    idx1++, protoList = protoList->next;
 
1741
  }
 
1742
 
 
1743
  for(i=0; i<myGlobals.numIpProtosToMonitor; i++) {
 
1744
    p[idx]  = (float)myGlobals.device[myGlobals.actualReportDeviceId].ipProtoStats[i].local.value
 
1745
      +myGlobals.device[myGlobals.actualReportDeviceId].ipProtoStats[i].remote.value;
 
1746
    p[idx] += (float)myGlobals.device[myGlobals.actualReportDeviceId].ipProtoStats[i].remote2local.value
 
1747
      +myGlobals.device[myGlobals.actualReportDeviceId].ipProtoStats[i].local2remote.value;
 
1748
    if((p[idx] > 0) && ((p[idx]*100/total) > 1 /* the proto is at least 1% */)) {
 
1749
      partialTotal += p[idx];
 
1750
      lbl[idx] = myGlobals.protoIPTrafficInfos[i];
 
1751
      idx++;
 
1752
    }
 
1753
 
 
1754
    if(idx >= maxNumDisplayProto) break;
 
1755
  }
 
1756
 
 
1757
  /*  Add a bar for the Other TCP/UDP based protocols
 
1758
      Courtesy of Robbert Kouprie <r.kouprie@dto.tudelft.nl>
 
1759
  */
 
1760
  if (total > partialTotal) {
 
1761
    lbl[idx] = "Other";
 
1762
    p[idx] = total - partialTotal;
 
1763
    idx++;
 
1764
  }
 
1765
 
 
1766
#ifndef WIN32
 
1767
  /* Unices */
 
1768
 
 
1769
  if(myGlobals.newSock < 0)
 
1770
    useFdOpen = 0;
 
1771
  else
 
1772
    useFdOpen = 1;
 
1773
 
 
1774
  if(useFdOpen)
 
1775
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1776
  else
 
1777
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1778
#else
 
1779
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1780
#endif
 
1781
 
 
1782
  drawBar(600, 300,     /* width/height */
 
1783
          fd,           /* open file pointer */
 
1784
          idx,          /* number of slices */
 
1785
          lbl,          /* slice labels */
 
1786
          p);           /* data array */
 
1787
 
 
1788
  fclose(fd);
 
1789
 
 
1790
  if(!useFdOpen)
 
1791
    sendGraphFile(fileName, 0);
 
1792
}
 
1793
 
 
1794
/* ******************************** */
 
1795
 
 
1796
int drawHostsDistanceGraph(int checkOnly) {
 
1797
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1798
  int i, j, numPoints=0;
 
1799
  char  *lbls[32], labels[32][8];
 
1800
  FILE *fd;
 
1801
  float graphData[60];
 
1802
  int useFdOpen = 0;
 
1803
  HostTraffic *el;
 
1804
 
 
1805
  memset(graphData, 0, sizeof(graphData));
 
1806
 
 
1807
  for(i=0; i<=30; i++) {
 
1808
    if(snprintf(labels[i], sizeof(labels[i]), "%d", i) < 0)
 
1809
      BufferTooShort();
 
1810
    lbls[i] = labels[i];
 
1811
    graphData[i] = 0;
 
1812
  }
 
1813
 
 
1814
  for(el=getFirstHost(myGlobals.actualReportDeviceId);
 
1815
      el != NULL; el = getNextHost(myGlobals.actualReportDeviceId, el)) {
 
1816
    if(!subnetPseudoLocalHost(el)) {
 
1817
      j = guessHops(el);
 
1818
      if((j > 0) && (j <= 30)) {
 
1819
        graphData[j]++;
 
1820
        numPoints++;
 
1821
      }
 
1822
    }
 
1823
  } /* for */
 
1824
 
 
1825
  if(checkOnly)
 
1826
    return(numPoints);
 
1827
 
 
1828
#ifndef WIN32
 
1829
  /* Unices */
 
1830
 
 
1831
  if(myGlobals.newSock < 0)
 
1832
    useFdOpen = 0;
 
1833
  else
 
1834
    useFdOpen = 1;
 
1835
 
 
1836
  if(useFdOpen)
 
1837
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1838
  else
 
1839
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1840
#else
 
1841
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1842
#endif
 
1843
 
 
1844
  drawArea(400, 250,    /* width, height           */
 
1845
           fd,          /* open FILE pointer       */
 
1846
           30,          /* num points per data set */
 
1847
           lbls,        /* X labels array of char* */
 
1848
           graphData, "Hops (TTL)",
 
1849
           "Number of Hosts", 0);
 
1850
 
 
1851
  fclose(fd);
 
1852
 
 
1853
  if(!useFdOpen)
 
1854
    sendGraphFile(fileName, 0);
 
1855
 
 
1856
  return(numPoints);
 
1857
}
 
1858
 
 
1859
/* ************************ */
 
1860
 
 
1861
void hostFcTrafficDistrib(HostTraffic *theHost, short dataSent) {
 
1862
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1863
  float p[MAX_NUM_PROTOS];
 
1864
  char  *lbl[] = { "", "", "", "", "", "", "", "", "",
 
1865
                   "", "", "", "", "", "", "", "", "", "" };
 
1866
  int i, num=0, explodePieces[MAX_NUM_PROTOS];
 
1867
  FILE *fd;
 
1868
  TrafficCounter traffic, totalFcTraffic, diffTraffic;
 
1869
  char *lblstouse[] = { "SCSI", "FICON", "ELS", "NS", "IP/FC", "Others"};
 
1870
  Counter protoTrafficSent[] = {
 
1871
      theHost->fcFcpBytesSent.value,
 
1872
      theHost->fcFiconBytesSent.value,
 
1873
      theHost->fcElsBytesSent.value,
 
1874
      theHost->fcDnsBytesSent.value,
 
1875
      theHost->fcIpfcBytesSent.value,
 
1876
      theHost->otherFcBytesSent.value,
 
1877
  };
 
1878
 
 
1879
  Counter protoTrafficRcvd[] = {
 
1880
      theHost->fcFcpBytesRcvd.value,
 
1881
      theHost->fcFiconBytesRcvd.value,
 
1882
      theHost->fcElsBytesRcvd.value,
 
1883
      theHost->fcDnsBytesRcvd.value,
 
1884
      theHost->fcIpfcBytesRcvd.value,
 
1885
      theHost->otherFcBytesRcvd.value,
 
1886
  };
 
1887
  int useFdOpen = 0;
 
1888
 
 
1889
  totalFcTraffic.value = 0;
 
1890
  diffTraffic.value = 0;
 
1891
 
 
1892
  if(dataSent)
 
1893
      totalFcTraffic.value = theHost->fcBytesSent.value;
 
1894
  else
 
1895
      totalFcTraffic.value = theHost->fcBytesRcvd.value;
 
1896
  
 
1897
  if(totalFcTraffic.value > 0) {
 
1898
      for (i = 0; i < 6; i++) {
 
1899
          if(dataSent) 
 
1900
              traffic.value = protoTrafficSent[i];
 
1901
          else 
 
1902
              traffic.value = protoTrafficRcvd[i];
 
1903
 
 
1904
          if(traffic.value > 0) {
 
1905
              p[num] = (float)((100*traffic.value)/totalFcTraffic.value);
 
1906
              diffTraffic.value += traffic.value;
 
1907
 
 
1908
              if(num == 0)
 
1909
                  explodePieces[num]=10;
 
1910
              else
 
1911
                  explodePieces[num]=explodePieces[num-1];
 
1912
              if (p[num]<5.0)
 
1913
                  explodePieces[num]+=9;
 
1914
              else if (p[num]>10.0)
 
1915
                  explodePieces[num]=10;
 
1916
              
 
1917
              lbl[num++] = lblstouse[i];
 
1918
          }
 
1919
      }
 
1920
  }
 
1921
 
 
1922
#ifndef WIN32
 
1923
  /* Unices */
 
1924
 
 
1925
  if(myGlobals.newSock < 0)
 
1926
    useFdOpen = 0;
 
1927
  else
 
1928
    useFdOpen = 1;
 
1929
  
 
1930
  if(useFdOpen)
 
1931
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
1932
  else
 
1933
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
1934
#else
 
1935
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
1936
#endif
 
1937
 
 
1938
  if(num == 1) p[0] = 100;
 
1939
 
 
1940
  if(num == 1) p[0] = 100; /* just to be safe */
 
1941
  drawPie(300, 250,
 
1942
          fd,                   /* open file pointer */
 
1943
          num,                  /* number of slices */
 
1944
          lbl,                  /* slice labels */
 
1945
          p);                   /* data array */
 
1946
 
 
1947
  fclose(fd);
 
1948
 
 
1949
  if(!useFdOpen)
 
1950
    sendGraphFile(fileName, 0);
 
1951
}
 
1952
 
 
1953
/* ********************************** */
 
1954
 
 
1955
void fcPktSizeDistribPie(void) {
 
1956
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
1957
  float p[10];
 
1958
  char  *lbl[] = { "", "", "", "", "", "", "", "", "", ""};
 
1959
  int num=0;
 
1960
  FILE *fd;
 
1961
  int useFdOpen = 0;
 
1962
 
 
1963
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo36.value > 0) {
 
1964
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo36.value)/
 
1965
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1966
    lbl[num++] = "<= 36";
 
1967
  };
 
1968
 
 
1969
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo48.value > 0) {
 
1970
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo48.value)/
 
1971
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1972
    lbl[num++] = "<= 48";
 
1973
  };
 
1974
 
 
1975
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo52.value > 0) {
 
1976
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo52.value)/
 
1977
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1978
    lbl[num++] = "<= 52";
 
1979
  };
 
1980
 
 
1981
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo68.value > 0) {
 
1982
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo68.value)/
 
1983
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1984
    lbl[num++] = "<= 68";
 
1985
  };
 
1986
 
 
1987
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo104.value > 0) {
 
1988
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo104.value)/
 
1989
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1990
    lbl[num++] = "<= 104";
 
1991
  };
 
1992
 
 
1993
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo548.value > 0) {
 
1994
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo548.value)/
 
1995
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
1996
    lbl[num++] = "<= 548";
 
1997
  };
 
1998
 
 
1999
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo1060.value > 0) {
 
2000
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo1060.value)/
 
2001
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
2002
    lbl[num++] = "<= 1060";
 
2003
  };
 
2004
 
 
2005
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo2136.value > 0) {
 
2006
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.upTo2136.value)/
 
2007
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
2008
    lbl[num++] = "<= 2136";
 
2009
  };
 
2010
 
 
2011
  if(myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.above2136.value > 0) {
 
2012
    p[num] = (float)(100*myGlobals.device[myGlobals.actualReportDeviceId].rcvdFcPktStats.above2136.value)/
 
2013
      (float)myGlobals.device[myGlobals.actualReportDeviceId].ethernetPkts.value;
 
2014
    lbl[num++] = "> 2136";
 
2015
  };
 
2016
 
 
2017
#ifndef WIN32
 
2018
  /* Unices */
 
2019
 
 
2020
  if(myGlobals.newSock < 0)
 
2021
    useFdOpen = 0;
 
2022
  else
 
2023
    useFdOpen = 1;
 
2024
 
 
2025
  if(useFdOpen)
 
2026
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2027
  else
 
2028
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2029
#else
 
2030
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2031
#endif
 
2032
 
 
2033
  if(num == 1) p[0] = 100; /* just to be safe */
 
2034
  drawPie(400, 250,
 
2035
          fd,                   /* open file pointer */
 
2036
          num,                  /* number of slices */
 
2037
          lbl,                  /* slice labels */
 
2038
          p);                   /* data array */
 
2039
 
 
2040
  fclose(fd);
 
2041
 
 
2042
  if(!useFdOpen)
 
2043
    sendGraphFile(fileName, 0);
 
2044
}
 
2045
 
 
2046
/* ******************************** */
 
2047
 
 
2048
void drawGlobalFcProtoDistribution(void) {
 
2049
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
2050
  int idx=0;
 
2051
  float p[256];
 
2052
  char *lbl[256];
 
2053
  FILE *fd;
 
2054
  int useFdOpen = 0;
 
2055
 
 
2056
  p[myGlobals.numIpProtosToMonitor] = 0;
 
2057
 
 
2058
  if(myGlobals.device[myGlobals.actualReportDeviceId].fcFcpBytes.value) {
 
2059
      p[idx]  = (float)myGlobals.device[myGlobals.actualReportDeviceId].fcFcpBytes.value;
 
2060
      lbl[idx++] = "SCSI";
 
2061
  }
 
2062
 
 
2063
  if (myGlobals.device[myGlobals.actualReportDeviceId].fcFiconBytes.value) {
 
2064
      p[idx] = (float)myGlobals.device[myGlobals.actualReportDeviceId].fcFiconBytes.value;
 
2065
      lbl[idx++] = "FICON";
 
2066
  }
 
2067
 
 
2068
  if (myGlobals.device[myGlobals.actualReportDeviceId].fcElsBytes.value) {
 
2069
      p[idx] = (float)myGlobals.device[myGlobals.actualReportDeviceId].fcElsBytes.value;
 
2070
      lbl[idx++] = "ELS";
 
2071
  }
 
2072
 
 
2073
  if (myGlobals.device[myGlobals.actualReportDeviceId].fcIpfcBytes.value) {
 
2074
      p[idx] = (float)myGlobals.device[myGlobals.actualReportDeviceId].fcIpfcBytes.value;
 
2075
      lbl[idx++] = "IP/FC";
 
2076
  }
 
2077
 
 
2078
  if (myGlobals.device[myGlobals.actualReportDeviceId].fcDnsBytes.value) {
 
2079
      p[idx] = (float)myGlobals.device[myGlobals.actualReportDeviceId].fcDnsBytes.value;
 
2080
      lbl[idx++] = "NS";
 
2081
  }
 
2082
 
 
2083
  if (myGlobals.device[myGlobals.actualReportDeviceId].fcSwilsBytes.value) {
 
2084
      p[idx] = (float)myGlobals.device[myGlobals.actualReportDeviceId].fcSwilsBytes.value;
 
2085
      lbl[idx++] = "SWILS";
 
2086
  }
 
2087
 
 
2088
  if (myGlobals.device[myGlobals.actualReportDeviceId].otherFcBytes.value) {
 
2089
      p[idx] = (float)myGlobals.device[myGlobals.actualReportDeviceId].otherFcBytes.value;
 
2090
      lbl[idx++] = "Others";
 
2091
  }
 
2092
 
 
2093
#ifndef WIN32
 
2094
  /* Unices */
 
2095
 
 
2096
  if(myGlobals.newSock < 0)
 
2097
    useFdOpen = 0;
 
2098
  else
 
2099
    useFdOpen = 1;
 
2100
  
 
2101
  if(useFdOpen)
 
2102
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2103
  else
 
2104
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
2105
#else
 
2106
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2107
#endif
 
2108
 
 
2109
  drawBar(600, 250,     /* width/height */
 
2110
          fd,           /* open file pointer */
 
2111
          idx,          /* number of slices */
 
2112
          lbl,          /* slice labels */
 
2113
          p);           /* data array */
 
2114
 
 
2115
  fclose(fd);
 
2116
 
 
2117
  if(!useFdOpen)
 
2118
    sendGraphFile(fileName, 0);
 
2119
}
 
2120
 
 
2121
void drawLunStatsBytesDistribution (HostTraffic *el) {
 
2122
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
2123
  int lun, numEntries, idx=0;
 
2124
  float p[MAX_LUNS_GRAPHED+1];
 
2125
  char *lbl[MAX_LUNS_GRAPHED+1];
 
2126
  char label[MAX_LUNS_GRAPHED+1][10];
 
2127
  LunStatsSortedEntry sortedLunTbl[MAX_LUNS_SUPPORTED];
 
2128
  LunStatsSortedEntry *entry;
 
2129
  FILE *fd;
 
2130
  int useFdOpen = 0;
 
2131
  ScsiLunTrafficInfo *lunStats;
 
2132
 
 
2133
  p[MAX_LUNS_GRAPHED] = 0;
 
2134
  numEntries = 0;
 
2135
 
 
2136
  memset(sortedLunTbl, 0, sizeof (sortedLunTbl));
 
2137
 
 
2138
  for (lun=0, numEntries=0; lun < MAX_LUNS_SUPPORTED; lun++) {
 
2139
      if ((lunStats = el->activeLuns[lun]) != NULL) {
 
2140
          sortedLunTbl[numEntries].lun = lun;
 
2141
          sortedLunTbl[numEntries++].stats = el->activeLuns[lun];
 
2142
      }
 
2143
  }
 
2144
 
 
2145
  myGlobals.columnSort = 4;     /* This is based on total I/O */
 
2146
  qsort (sortedLunTbl, numEntries, sizeof (LunStatsSortedEntry), cmpLunFctn);
 
2147
 
 
2148
  idx = 0;
 
2149
  for (lun = numEntries-1; ((idx < MAX_LUNS_GRAPHED) && (lun >= 0));
 
2150
       lun--) {
 
2151
      entry = &sortedLunTbl[lun];
 
2152
      p[idx] = (float) (entry->stats->bytesSent.value +
 
2153
                        entry->stats->bytesRcvd.value);
 
2154
      if (p[idx] > 0) {
 
2155
          sprintf (label[idx],"%hd", entry->lun);
 
2156
          lbl[idx] = label[idx];
 
2157
          idx++;
 
2158
      }
 
2159
  }
 
2160
  
 
2161
#ifndef WIN32
 
2162
  /* Unices */
 
2163
 
 
2164
  if(myGlobals.newSock < 0)
 
2165
    useFdOpen = 0;
 
2166
  else
 
2167
    useFdOpen = 1;
 
2168
  
 
2169
  if(useFdOpen)
 
2170
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2171
  else
 
2172
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
2173
#else
 
2174
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2175
#endif
 
2176
 
 
2177
  drawBar (600, 250,    /* width/height */
 
2178
           fd,          /* open file pointer */
 
2179
           idx,     /* number of slices */
 
2180
           lbl,         /* slice labels */
 
2181
           p);          /* data array */
 
2182
 
 
2183
  fclose(fd);
 
2184
 
 
2185
  if(!useFdOpen)
 
2186
    sendGraphFile(fileName, 0);
 
2187
}
 
2188
 
 
2189
void drawLunStatsPktsDistribution (HostTraffic *el) {
 
2190
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
2191
  int lun, numEntries, idx=0;
 
2192
  float p[MAX_LUNS_GRAPHED+1];
 
2193
  char *lbl[MAX_LUNS_GRAPHED+1];
 
2194
  char label[MAX_LUNS_GRAPHED+1][10];
 
2195
  FILE *fd;
 
2196
  int useFdOpen = 0;
 
2197
  ScsiLunTrafficInfo *lunStats;
 
2198
  LunStatsSortedEntry sortedLunTbl[MAX_LUNS_SUPPORTED];
 
2199
  LunStatsSortedEntry *entry;
 
2200
 
 
2201
  p[MAX_LUNS_GRAPHED] = 0;
 
2202
  numEntries = 0;
 
2203
 
 
2204
  memset(sortedLunTbl, 0, sizeof (sortedLunTbl));
 
2205
 
 
2206
  for (lun=0, numEntries=0; lun < MAX_LUNS_SUPPORTED; lun++) {
 
2207
      if ((lunStats = el->activeLuns[lun]) != NULL) {
 
2208
          sortedLunTbl[numEntries].lun = lun;
 
2209
          sortedLunTbl[numEntries++].stats = el->activeLuns[lun];
 
2210
      }
 
2211
  }
 
2212
 
 
2213
  printf ("drawLunStatsPktsDistribution: #entries = %d\n", numEntries);
 
2214
  myGlobals.columnSort = 5;     /* This is based on total frames */
 
2215
  qsort (sortedLunTbl, numEntries, sizeof (LunStatsSortedEntry), cmpLunFctn);
 
2216
  
 
2217
  for (lun = numEntries-1; ((idx < MAX_LUNS_GRAPHED) && (lun >= 0));
 
2218
       lun--) {
 
2219
      entry = &sortedLunTbl[lun];
 
2220
      p[idx] = (float) (entry->stats->pktRcvd +
 
2221
                        entry->stats->pktSent);
 
2222
      if (p[idx] > 0) {
 
2223
          sprintf (label[idx],"%hd", entry->lun);
 
2224
          lbl[idx] = label[idx];
 
2225
          idx++;
 
2226
      }
 
2227
  }
 
2228
 
 
2229
#ifndef WIN32
 
2230
  /* Unices */
 
2231
 
 
2232
  traceEvent (CONST_TRACE_ALWAYSDISPLAY, "drawLunStatsPktsDistribution: idx = %d\n", idx);
 
2233
  if(myGlobals.newSock < 0)
 
2234
    useFdOpen = 0;
 
2235
  else
 
2236
    useFdOpen = 1;
 
2237
  
 
2238
  if(useFdOpen)
 
2239
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2240
  else
 
2241
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
2242
#else
 
2243
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2244
#endif
 
2245
 
 
2246
  drawBar (600, 250,    /* width/height */
 
2247
           fd,          /* open file pointer */
 
2248
           idx,     /* number of slices */
 
2249
           lbl,         /* slice labels */
 
2250
           p);          /* data array */
 
2251
 
 
2252
  fclose(fd);
 
2253
 
 
2254
  if(!useFdOpen)
 
2255
    sendGraphFile(fileName, 0);
 
2256
}
 
2257
 
 
2258
void drawVsanStatsBytesDistribution (int deviceId) {
 
2259
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
2260
  int numVsans, idx=0, i, j;
 
2261
  float p[MAX_VSANS_GRAPHED+1];
 
2262
  char *lbl[MAX_VSANS_GRAPHED+1];
 
2263
  char label[MAX_VSANS_GRAPHED+1][10];
 
2264
  FILE *fd;
 
2265
  int useFdOpen = 0;
 
2266
  FcFabricElementHash **theHash;
 
2267
  FcFabricElementHash *tmpTable[MAX_ELEMENT_HASH];
 
2268
  
 
2269
  if ((theHash = myGlobals.device[deviceId].vsanHash) == NULL) {
 
2270
      return;
 
2271
  }
 
2272
 
 
2273
  p[MAX_VSANS_GRAPHED] = 0;
 
2274
  numVsans = 0;
 
2275
 
 
2276
  memset (tmpTable, sizeof (FcFabricElementHash *)*MAX_ELEMENT_HASH, 0);
 
2277
  for (i=0; i<MAX_ELEMENT_HASH; i++) {
 
2278
      if((theHash[i] != NULL) && (theHash[i]->vsanId < MAX_HASHDUMP_ENTRY) &&
 
2279
         (theHash[i]->vsanId < MAX_USER_VSAN)) {
 
2280
          if (theHash[i]->totBytes.value)
 
2281
              tmpTable[numVsans++] = theHash[i];
 
2282
      }
 
2283
  }
 
2284
 
 
2285
  if (!numVsans) {
 
2286
      printNoDataYet ();
 
2287
      return;
 
2288
  }
 
2289
  
 
2290
  myGlobals.columnSort = 3;
 
2291
  qsort (tmpTable, numVsans, sizeof (FcFabricElementHash **), cmpVsanFctn);
 
2292
  
 
2293
  idx = 0;
 
2294
  for (i = numVsans-1, j = 0; i >= 0; i--, j++) {
 
2295
      if (tmpTable[i] != NULL) {
 
2296
          p[idx] = tmpTable[i]->totBytes.value;
 
2297
          if (tmpTable[i]->vsanId) {
 
2298
              sprintf (label[idx], "%hd", tmpTable[i]->vsanId);
 
2299
          }
 
2300
          else {
 
2301
              sprintf (label[idx], "N/A");
 
2302
          }
 
2303
          lbl[idx] = label[idx++];
 
2304
      }
 
2305
 
 
2306
      if (j >= MAX_VSANS_GRAPHED)
 
2307
          break;
 
2308
  }
 
2309
 
 
2310
  
 
2311
#ifndef WIN32
 
2312
  /* Unices */
 
2313
 
 
2314
  if(myGlobals.newSock < 0)
 
2315
    useFdOpen = 0;
 
2316
  else
 
2317
    useFdOpen = 1;
 
2318
  
 
2319
  if(useFdOpen)
 
2320
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2321
  else
 
2322
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
2323
#else
 
2324
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2325
#endif
 
2326
 
 
2327
  drawBar (600, 250,    /* width/height */
 
2328
           fd,          /* open file pointer */
 
2329
           idx,     /* number of slices */
 
2330
           lbl,         /* slice labels */
 
2331
           p);          /* data array */
 
2332
 
 
2333
  fclose(fd);
 
2334
 
 
2335
  if(!useFdOpen)
 
2336
    sendGraphFile(fileName, 0);
 
2337
}
 
2338
 
 
2339
void drawVsanStatsPktsDistribution (int deviceId) {
 
2340
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
2341
  int numVsans, idx=0, i, j;
 
2342
  float p[MAX_VSANS_GRAPHED+1];
 
2343
  char *lbl[MAX_VSANS_GRAPHED+1];
 
2344
  char label[MAX_VSANS_GRAPHED+1][10];
 
2345
  FILE *fd;
 
2346
  int useFdOpen = 0;
 
2347
  FcFabricElementHash **theHash;
 
2348
  FcFabricElementHash *tmpTable[MAX_ELEMENT_HASH];
 
2349
  
 
2350
  if ((theHash = myGlobals.device[deviceId].vsanHash) == NULL) {
 
2351
      return;
 
2352
  }
 
2353
 
 
2354
  p[MAX_VSANS_GRAPHED] = 0;
 
2355
  numVsans = 0;
 
2356
 
 
2357
  memset (tmpTable, sizeof (FcFabricElementHash *)*MAX_ELEMENT_HASH, 0);
 
2358
  for (i=0; i<MAX_ELEMENT_HASH; i++) {
 
2359
      if((theHash[i] != NULL) && (theHash[i]->vsanId < MAX_HASHDUMP_ENTRY) &&
 
2360
         (theHash[i]->vsanId < MAX_USER_VSAN)) {
 
2361
          if (theHash[i]->totPkts.value)
 
2362
              tmpTable[numVsans++] = theHash[i];
 
2363
      }
 
2364
  }
 
2365
 
 
2366
  if (!numVsans) {
 
2367
      printNoDataYet ();
 
2368
      return;
 
2369
  }
 
2370
  
 
2371
  myGlobals.columnSort = 4;
 
2372
  qsort (tmpTable, numVsans, sizeof (FcFabricElementHash **), cmpVsanFctn);
 
2373
  
 
2374
  idx = 0;
 
2375
  for (i = numVsans-1, j = 0; i >= 0; i--, j++) {
 
2376
      if (tmpTable[i] != NULL) {
 
2377
          p[idx] = tmpTable[i]->totPkts.value;
 
2378
          if (tmpTable[i]->vsanId) {
 
2379
              sprintf (label[idx], "%d", tmpTable[i]->vsanId);
 
2380
          }
 
2381
          else {
 
2382
              sprintf (label[idx], "N/A");
 
2383
          }
 
2384
          lbl[idx] = label[idx++];
 
2385
      }
 
2386
 
 
2387
      if (j >= MAX_VSANS_GRAPHED)
 
2388
          break;
 
2389
  }
 
2390
 
 
2391
#ifndef WIN32
 
2392
  /* Unices */
 
2393
 
 
2394
  if(myGlobals.newSock < 0)
 
2395
    useFdOpen = 0;
 
2396
  else
 
2397
    useFdOpen = 1;
 
2398
  
 
2399
  if(useFdOpen)
 
2400
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2401
  else
 
2402
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
2403
#else
 
2404
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2405
#endif
 
2406
 
 
2407
  drawBar (600, 250,    /* width/height */
 
2408
           fd,          /* open file pointer */
 
2409
           idx,     /* number of slices */
 
2410
           lbl,         /* slice labels */
 
2411
           p);          /* data array */
 
2412
 
 
2413
  fclose(fd);
 
2414
 
 
2415
  if(!useFdOpen)
 
2416
    sendGraphFile(fileName, 0);
 
2417
}
 
2418
 
 
2419
void drawVsanSwilsProtoDistribution(u_short vsanId) {
 
2420
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
2421
  int idx=0;
 
2422
  FcFabricElementHash *hash;
 
2423
  float p[256];
 
2424
  char *lbl[256];
 
2425
  FILE *fd;
 
2426
  int useFdOpen = 0;
 
2427
 
 
2428
  p[myGlobals.numIpProtosToMonitor] = 0;
 
2429
 
 
2430
  hash = getFcFabricElementHash (vsanId, myGlobals.actualReportDeviceId);
 
2431
  
 
2432
  p[0] = (float)hash->dmBytes.value;
 
2433
  if (p[0] > 0) {
 
2434
      p[myGlobals.numIpProtosToMonitor] += p[0];
 
2435
      lbl[idx++] = "DM";
 
2436
  }
 
2437
 
 
2438
  p[1] = (float)hash->fspfBytes.value;
 
2439
  if (p[1] > 0) {
 
2440
      p[myGlobals.numIpProtosToMonitor] += p[1];
 
2441
      lbl[idx++] = "FSPF";
 
2442
  }
 
2443
 
 
2444
  p[2] = (float)hash->nsBytes.value;
 
2445
  if (p[2] > 0) {
 
2446
      p[myGlobals.numIpProtosToMonitor] += p[2];
 
2447
      lbl[idx++] = "NS";
 
2448
  }
 
2449
 
 
2450
  p[3] = (float)hash->zsBytes.value;
 
2451
  if (p[3] > 0) {
 
2452
      p[myGlobals.numIpProtosToMonitor] += p[3];
 
2453
      lbl[idx++] = "ZS";
 
2454
  }
 
2455
 
 
2456
  p[4] = (float)hash->rscnBytes.value;
 
2457
  if (p[4] > 0) {
 
2458
      p[myGlobals.numIpProtosToMonitor] += p[4];
 
2459
      lbl[idx++] = "SW_RSCN";
 
2460
  }
 
2461
 
 
2462
  p[5] = (float)hash->fcsBytes.value;
 
2463
  if (p[5] > 0) {
 
2464
      p[myGlobals.numIpProtosToMonitor] += p[5];
 
2465
      lbl[idx++] = "FCS";
 
2466
  }
 
2467
 
 
2468
  p[6] = (float)hash->otherCtlBytes.value;
 
2469
  if (p[6] > 0) {
 
2470
      p[myGlobals.numIpProtosToMonitor] += p[6];
 
2471
      lbl[idx++] = "Others";
 
2472
  }
 
2473
 
 
2474
#ifndef WIN32
 
2475
  /* Unices */
 
2476
 
 
2477
  if(myGlobals.newSock < 0)
 
2478
    useFdOpen = 0;
 
2479
  else
 
2480
    useFdOpen = 1;
 
2481
  
 
2482
  if(useFdOpen)
 
2483
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2484
  else
 
2485
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
2486
#else
 
2487
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2488
#endif
 
2489
 
 
2490
  drawPie (600, 250,    /* width/height */
 
2491
           fd,          /* open file pointer */
 
2492
           idx,         /* number of slices */
 
2493
           lbl,         /* slice labels */
 
2494
           p);          /* data array */
 
2495
 
 
2496
  fclose(fd);
 
2497
 
 
2498
  if(!useFdOpen)
 
2499
    sendGraphFile(fileName, 0);
 
2500
}
 
2501
 
 
2502
void drawVsanDomainTrafficDistribution(u_short vsanId, u_char dataSent) {
 
2503
  char fileName[NAME_MAX] = "/tmp/graph-XXXXXX";
 
2504
  int i, idx=0, numEntries = 0;
 
2505
  FcFabricElementHash *hash;
 
2506
  float p[MAX_VSANS_GRAPHED+1];
 
2507
  char *lbl[MAX_VSANS_GRAPHED+1], labels[MAX_VSANS_GRAPHED+1][8];
 
2508
  FILE *fd;
 
2509
  int useFdOpen = 0;
 
2510
  Counter total;
 
2511
  SortedFcDomainStatsEntry *fcDomainStats;
 
2512
 
 
2513
  p[MAX_FC_DOMAINS+1] = 0;
 
2514
 
 
2515
  hash = getFcFabricElementHash (vsanId, myGlobals.actualReportDeviceId);
 
2516
 
 
2517
  if (hash == NULL) {
 
2518
      printNoDataYet();
 
2519
      return;
 
2520
  }
 
2521
 
 
2522
  fcDomainStats = (SortedFcDomainStatsEntry *)malloc (MAX_FC_DOMAINS*sizeof (SortedFcDomainStatsEntry));
 
2523
  if (fcDomainStats == NULL) {
 
2524
      traceEvent (CONST_TRACE_WARNING, "Unable to allocate memory for SortedFcDomainStatsEntry\n");
 
2525
      printNoDataYet();
 
2526
      return;
 
2527
  }
 
2528
  memset (fcDomainStats, 0, MAX_FC_DOMAINS*sizeof (SortedFcDomainStatsEntry));
 
2529
  
 
2530
  for (i = 1; i < MAX_FC_DOMAINS; i++) {
 
2531
      if (dataSent) {
 
2532
          if (hash->domainStats[i].sentBytes.value) {
 
2533
              fcDomainStats[numEntries].domainId = i;
 
2534
              fcDomainStats[numEntries++].stats = &hash->domainStats[i];
 
2535
          }
 
2536
      }
 
2537
      else {
 
2538
          if (hash->domainStats[i].rcvdBytes.value) {
 
2539
              fcDomainStats[numEntries].domainId = i;
 
2540
              fcDomainStats[numEntries++].stats = &hash->domainStats[i];
 
2541
          }
 
2542
      }
 
2543
  }
 
2544
 
 
2545
  if (numEntries == 0) {
 
2546
      printNoDataYet();
 
2547
      return;
 
2548
  }
 
2549
 
 
2550
  myGlobals.columnSort = dataSent;
 
2551
  qsort (fcDomainStats, numEntries, sizeof (SortedFcDomainStatsEntry), cmpFcDomainFctn);
 
2552
  
 
2553
  for (i = numEntries-1; (idx < MAX_VSANS_GRAPHED) && (i >= 0); i--) {
 
2554
      if (dataSent) {
 
2555
          total = fcDomainStats[i].stats->sentBytes.value;
 
2556
      }
 
2557
      else {
 
2558
          total = fcDomainStats[i].stats->rcvdBytes.value;
 
2559
      }
 
2560
      if (total > 0) {
 
2561
          p[idx] = (float)total;
 
2562
          sprintf (labels[idx], "%x", fcDomainStats[i].domainId);
 
2563
          lbl[idx] = labels[idx];
 
2564
          idx++;
 
2565
      }
 
2566
  }
 
2567
#ifndef WIN32
 
2568
  /* Unices */
 
2569
 
 
2570
  if(myGlobals.newSock < 0)
 
2571
    useFdOpen = 0;
 
2572
  else
 
2573
    useFdOpen = 1;
 
2574
  
 
2575
  if(useFdOpen)
 
2576
    fd = fdopen(abs(myGlobals.newSock), "ab");
 
2577
  else
 
2578
    fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */  
 
2579
#else
 
2580
  fd = getNewRandomFile(fileName, NAME_MAX); /* leave it inside the mutex */
 
2581
#endif
 
2582
 
 
2583
  drawBar(600, 250,     /* width/height */
 
2584
          fd,           /* open file pointer */
 
2585
          idx,          /* number of slices */
 
2586
          lbl,          /* slice labels */
 
2587
          p);           /* data array */
 
2588
 
 
2589
  fclose(fd);
 
2590
 
 
2591
  if(!useFdOpen)
 
2592
    sendGraphFile(fileName, 0);
 
2593
}
 
2594
 
 
2595
 
 
2596
#endif /* EMBEDDED */