← Back to branch summary

~ubuntu-branches/ubuntu/wily/ntop/wily-proposed

« back to all changes in this revision

Viewing changes to ntop/emitter.c

  • Committer: Bazaar Package Importer
  • Author(s): Dennis Schoen
  • Date: 2002-04-12 11:38:47 UTC
  • Revision ID: james.westby@ubuntu.com-20020412113847-4k4yydw0pzybc6g8
Tags: upstream-2.0.0
Import upstream version 2.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
ntop/emitter.c
 
1
/*
 
2
 *  Copyright (C) 2001 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
#include "ntop.h"
 
22
#include "globals-report.h"
 
23
 
 
24
#define PERL_LANGUAGE       1
 
25
#define PHP_LANGUAGE        2
 
26
#define NO_LANGUAGE         3
 
27
#define NB_LANGUAGES        3
 
28
#define DEFAULT_LANGUAGE    NO_LANGUAGE
 
29
 
 
30
 
 
31
/*
 
32
   This file has been significantly reworked
 
33
   by Philippe Bereski <Philippe.Bereski@ms.alcatel.fr>
 
34
 
 
35
   Many thanks Philippe!
 
36
*/
 
37
char *languages[] = {"", "perl", "php", "no" };
 
38
char buf[256];
 
39
 
 
40
/* *************************** */
 
41
 
 
42
void initWriteArray( int lang ) {
 
43
  switch(lang) {
 
44
  case PERL_LANGUAGE :
 
45
    sendString("%ntopHash =(\n");
 
46
    break ;
 
47
  case PHP_LANGUAGE :
 
48
    sendString("$ntopHash = array(\n");
 
49
    break ;
 
50
  case NO_LANGUAGE :
 
51
    break ;
 
52
  }
 
53
}
 
54
 
 
55
/* *************************** */
 
56
 
 
57
void endWriteArray(int lang) {
 
58
  switch(lang) {
 
59
  case PERL_LANGUAGE :
 
60
  case PHP_LANGUAGE :
 
61
    sendString(");\n");
 
62
    break ;
 
63
  case NO_LANGUAGE :
 
64
    sendString("\n");
 
65
    break ;
 
66
  }
 
67
}
 
68
 
 
69
/* *************************** */
 
70
 
 
71
void initWriteKey(int lang, char *indent, char *keyName) {
 
72
  switch(lang) {
 
73
  case PERL_LANGUAGE :
 
74
    if(snprintf(buf, sizeof(buf), "%s'%s' => {\n",indent, keyName) < 0)
 
75
      traceEvent(TRACE_ERROR, "Buffer overflow!");
 
76
    sendString(buf);
 
77
    break ;
 
78
  case PHP_LANGUAGE :
 
79
    if(snprintf(buf, sizeof(buf), "%s'%s' => array(\n",indent, keyName) < 0)
 
80
      traceEvent(TRACE_ERROR, "Buffer overflow!");
 
81
    sendString(buf);
 
82
    break ;
 
83
  case NO_LANGUAGE :
 
84
 
 
85
    break ;
 
86
  }
 
87
}
 
88
 
 
89
/* *************************** */
 
90
 
 
91
void endWriteKey(int lang, char *indent, char last) {
 
92
  /* If there is no indentation, this was the first level of key,
 
93
     hence the end of the list. Don't add a ',' at end.
 
94
  */
 
95
  switch(lang) {
 
96
  case PERL_LANGUAGE :
 
97
    if(snprintf(buf, sizeof(buf),"%s}%c\n",indent,last) < 0)
 
98
      traceEvent(TRACE_ERROR, "Buffer overflow!");
 
99
    sendString(buf);
 
100
    break ;
 
101
  case PHP_LANGUAGE :
 
102
    if(snprintf(buf, sizeof(buf),"%s)%c\n",indent,last) < 0)
 
103
      traceEvent(TRACE_ERROR, "Buffer overflow!");
 
104
    sendString(buf);
 
105
    break ;
 
106
  case NO_LANGUAGE :
 
107
    if( indent == "") sendString("\n");
 
108
    break ;
 
109
  }
 
110
}
 
111
 
 
112
/* *************************** */
 
113
 
 
114
void wrtStrItm(int lang, char *indent, char *name, char *value, char last) {
 
115
  switch(lang) {
 
116
  case PERL_LANGUAGE :
 
117
  case PHP_LANGUAGE :
 
118
    /* In the case of hostNumIpAddress and hostSymIpAddress,
 
119
       the pointer is not null, but the string is empty.
 
120
       In that case, don't create the key in the array.
 
121
    */
 
122
    if(( value != NULL ) &&( value[0] != '\0'))  {
 
123
      if(snprintf(buf, sizeof(buf), "%s'%s' => '%s'%c\n", indent,name,value,last) < 0)
 
124
        traceEvent(TRACE_ERROR, "Buffer overflow!");  sendString(buf);
 
125
    }
 
126
    break ;
 
127
  case NO_LANGUAGE :
 
128
    if( value != NULL ) {
 
129
      if(snprintf(buf, sizeof(buf), "%s|",value) < 0)
 
130
        traceEvent(TRACE_ERROR, "Buffer overflow!");  sendString(buf);
 
131
    } else {
 
132
      if(snprintf(buf, sizeof(buf), "%s|","") < 0)
 
133
        traceEvent(TRACE_ERROR, "Buffer overflow!");  sendString(buf);
 
134
    }
 
135
    break ;
 
136
  }
 
137
}
 
138
 
 
139
/* *************************** */
 
140
 
 
141
void wrtIntItm(int lang, char *indent, char *name, int value, char last) {
 
142
  char buf[80];
 
143
  sprintf(buf,"%d",value);
 
144
  wrtStrItm(lang, indent, name,  buf, last);
 
145
}
 
146
 
 
147
/* *************************** */
 
148
 
 
149
void wrtIntStrItm(int lang, char *indent,int name, char *value, char useless) {
 
150
  char buf[80];
 
151
  sprintf(buf,"%d",name);
 
152
  wrtStrItm(lang, indent, buf,  value, ',');
 
153
}
 
154
 
 
155
/* *************************** */
 
156
 
 
157
void wrtUintItm(int lang, char *indent, char *name, unsigned int value, char useless) {
 
158
  char buf[80];
 
159
  sprintf(buf,"%d",value);
 
160
  wrtStrItm(lang, indent, name,  buf, ',');
 
161
}
 
162
 
 
163
/* *************************** */
 
164
 
 
165
void wrtUcharItm(int lang, char *indent, char *name, u_char value, char useless) {
 
166
  char buf[80];
 
167
  sprintf(buf,"%d",value);
 
168
  wrtStrItm(lang, indent, name,  buf, ',');
 
169
}
 
170
 
 
171
/* *************************** */
 
172
 
 
173
void wrtFloatItm(int lang, char *indent, char *name, float value, char last) {
 
174
  char buf[80];
 
175
  sprintf(buf,"%0.2f",value);
 
176
  wrtStrItm(lang, indent, name, buf, last);
 
177
}
 
178
 
 
179
/* *************************** */
 
180
 
 
181
void wrtIntFloatItm(int lang, char *indent, int name, float value, char last) {
 
182
  char buf[80];
 
183
  sprintf(buf,"%d",name);
 
184
  wrtFloatItm(lang, indent, buf, value, last);
 
185
}
 
186
 
 
187
/* *************************** */
 
188
 
 
189
void wrtUlongItm(int lang, char *indent, char *name, unsigned long value, char useless) {
 
190
  char buf[80];
 
191
  sprintf(buf,"%lu",value);
 
192
  wrtStrItm(lang, indent, name,  buf, ',');
 
193
}
 
194
 
 
195
/* *************************** */
 
196
 
 
197
void wrtLlongItm(int lang, char* indent, char* name, TrafficCounter value, char last) {
 
198
  char buf[80];
 
199
  sprintf(buf,"%llu",value);
 
200
  wrtStrItm(lang, indent, name, buf, last);
 
201
}
 
202
 
 
203
/* *************************** */
 
204
 
 
205
void wrtTime_tItm(int lang, char *indent, char *name, time_t value, char useless) {
 
206
  char buf[80];
 
207
  sprintf(buf,"%ld",value);
 
208
  wrtStrItm(lang, indent, name, buf, ',');
 
209
}
 
210
 
 
211
/* *************************** */
 
212
 
 
213
void wrtUshortItm(int lang, char *indent, char *name, u_short value, char useless) {
 
214
  char buf[80];
 
215
  sprintf(buf,"%d",value);
 
216
  wrtStrItm(lang, indent, name,  buf, ',');
 
217
}
 
218
 
 
219
/* ********************************** */
 
220
 
 
221
static int checkFilter(char* theFilter,
 
222
                       struct re_pattern_buffer *filterPattern,
 
223
                       char* strToMatch) {
 
224
  if((theFilter == NULL) || (theFilter[0] == '\0'))
 
225
    return(1);
 
226
  else if(strToMatch == NULL)
 
227
    return(0);
 
228
  else {
 
229
    int length = strlen(strToMatch);
 
230
 
 
231
    if(re_search(filterPattern, strToMatch, length, 0, length, 0) < 0)
 
232
      return(0); /* No Match */
 
233
    else
 
234
      return(1);
 
235
  }
 
236
}
 
237
 
 
238
/* ********************************** */
 
239
 
 
240
void dumpNtopHashes(char* options) {
 
241
  char key[64], filter[128];
 
242
  unsigned int idx, numEntries=0, lang=DEFAULT_LANGUAGE, j;
 
243
  HostTraffic *el;
 
244
  struct re_pattern_buffer filterPattern;
 
245
 
 
246
  memset(key, 0, sizeof(key));
 
247
  memset(filter, 0, sizeof(filter));
 
248
 
 
249
  if(options != NULL) {
 
250
    /* language now defined into "languages[]" */
 
251
    char *tmpStr, *strtokState;
 
252
 
 
253
    tmpStr = strtok_r(options, "&", &strtokState);
 
254
 
 
255
    while(tmpStr != NULL) {
 
256
      int i=0; int j;
 
257
 
 
258
      while((tmpStr[i] != '\0') &&(tmpStr[i] != '='))
 
259
        i++;
 
260
 
 
261
      /* If argument contains "language=something", then
 
262
         look in the table "languages" of known language for
 
263
         the choosen language.
 
264
      */
 
265
 
 
266
      if(tmpStr[i] == '=') {
 
267
        tmpStr[i] = 0;
 
268
 
 
269
        if(strcasecmp(tmpStr, "language") == 0) {
 
270
          lang=DEFAULT_LANGUAGE;
 
271
          for(j=1;j <= NB_LANGUAGES;j++) {
 
272
            if(strcasecmp(&tmpStr[i+1], languages[j]) == 0)
 
273
              lang = j;
 
274
          }
 
275
        } else if(strcmp(tmpStr, "key") == 0) {
 
276
          strncpy(key, &tmpStr[i+1], sizeof(key));
 
277
        } else if(strcmp(tmpStr, "filter") == 0) {
 
278
          strncpy(filter, &tmpStr[i+1], sizeof(filter));
 
279
        }
 
280
      }
 
281
 
 
282
      tmpStr = strtok_r(NULL, "&", &strtokState);
 
283
    }
 
284
  }
 
285
 
 
286
  if(filter[0] != '\0') {
 
287
    const char *re_err;
 
288
 
 
289
    memset(&filterPattern, 0, sizeof(struct re_pattern_buffer));
 
290
 
 
291
    re_err = (const char *)re_compile_pattern(filter, strlen(filter), &filterPattern);
 
292
    if(re_err) {
 
293
      /* Invalid pattern */
 
294
      filter[0] = '\0';
 
295
    } else {
 
296
      filterPattern.fastmap =(char*)malloc(256);
 
297
 
 
298
      if(re_compile_fastmap(&filterPattern)) {
 
299
        /* Invalid pattern */
 
300
        free(filterPattern.fastmap);
 
301
        filter[0] = '\0';
 
302
      }
 
303
    }
 
304
  }
 
305
 
 
306
  initWriteArray(lang);
 
307
 
 
308
  for(idx=0; idx<device[actualDeviceId].actualHashSize; idx++) {
 
309
    if((el = device[actualReportDeviceId].hash_hostTraffic[idx]) != NULL) {
 
310
      char *hostKey;
 
311
 
 
312
      if(key[0] != '\0') {
 
313
        if(strcmp(el->hostNumIpAddress, key)
 
314
           && strcmp(el->ethAddressString, key)
 
315
           && strcmp(el->hostSymIpAddress, key))
 
316
          continue;
 
317
      }
 
318
 
 
319
      if(el->hostNumIpAddress[0] != '\0')
 
320
        hostKey = el->hostNumIpAddress;
 
321
      else
 
322
        hostKey = el->ethAddressString;
 
323
 
 
324
      if(numEntries > 0) { endWriteKey(lang,"",','); }
 
325
 
 
326
      initWriteKey(lang, "", hostKey);
 
327
 
 
328
      /* ************************ */
 
329
 
 
330
      if(checkFilter(filter, &filterPattern, "index")) wrtUintItm(lang, "\t","index", idx,' ');
 
331
 
 
332
      if(checkFilter(filter, &filterPattern, "hostNumIpAddress")) wrtStrItm(lang, "\t", "hostNumIpAddress", el->hostNumIpAddress,',');
 
333
      if(checkFilter(filter, &filterPattern, "hostSymIpAddress")) wrtStrItm(lang, "\t", "hostSymIpAddress", el->hostSymIpAddress,',');
 
334
 
 
335
      if(checkFilter(filter, &filterPattern, "firstSeen")) wrtTime_tItm(lang, "\t", "firstSeen",   el->firstSeen,' ');
 
336
      if(checkFilter(filter, &filterPattern, "lastSeen")) wrtTime_tItm(lang, "\t", "lastSeen",    el->lastSeen,' ');
 
337
      if(checkFilter(filter, &filterPattern, "minTTL")) wrtUshortItm(lang, "\t", "minTTL",       el->minTTL,' ');
 
338
      if(checkFilter(filter, &filterPattern, "maxTTL")) wrtUshortItm(lang, "\t", "maxTTL",       el->maxTTL,' ');
 
339
      if(checkFilter(filter, &filterPattern, "nbHostName")) wrtStrItm(lang, "\t", "nbHostName",     el->nbHostName,',');
 
340
      if(checkFilter(filter, &filterPattern, "nbDomainName")) wrtStrItm(lang, "\t", "nbDomainName",   el->nbDomainName,',');
 
341
      if(checkFilter(filter, &filterPattern, "nbDescr")) wrtStrItm(lang, "\t", "nbDescr",        el->nbDescr,',');
 
342
      if(checkFilter(filter, &filterPattern, "nodeType")) wrtUcharItm (lang, "\t", "nodeType",    el->nbNodeType,' ');
 
343
      if(checkFilter(filter, &filterPattern, "atNodeName")) wrtStrItm(lang, "\t", "atNodeName",     el->atNodeName,',');
 
344
      if(checkFilter(filter, &filterPattern, "atNetwork")) wrtUshortItm(lang, "\t", "atNetwork",    el->atNetwork,' ');
 
345
      if(checkFilter(filter, &filterPattern, "atNode")) wrtUcharItm (lang, "\t", "atNode",      el->atNode,' ');
 
346
      if(checkFilter(filter, &filterPattern, "ipxHostName")) wrtStrItm(lang, "\t", "ipxHostName",    el->ipxHostName,',');
 
347
      if(checkFilter(filter, &filterPattern, "pktSent")) wrtLlongItm(lang, "\t", "pktSent",     el->pktSent,',');
 
348
      if(checkFilter(filter, &filterPattern, "pktReceived")) wrtLlongItm(lang, "\t", "pktReceived", el->pktReceived,',');
 
349
      if(checkFilter(filter, &filterPattern, "pktDuplicatedAckSent")) wrtLlongItm(lang, "\t", "pktDuplicatedAckSent",el->pktDuplicatedAckSent,',');
 
350
      if(checkFilter(filter, &filterPattern, "pktDuplicatedAckRcvd")) wrtLlongItm(lang, "\t", "pktDuplicatedAckRcvd",el->pktDuplicatedAckRcvd,',');
 
351
      if(checkFilter(filter, &filterPattern, "pktBroadcastSent")) wrtLlongItm(lang, "\t", "pktBroadcastSent",    el->pktBroadcastSent,',');
 
352
      if(checkFilter(filter, &filterPattern, "bytesMulticastSent")) wrtLlongItm(lang, "\t", "bytesMulticastSent",  el->bytesMulticastSent,',');
 
353
      if(checkFilter(filter, &filterPattern, "pktMulticastSent")) wrtLlongItm(lang, "\t", "pktMulticastSent",    el->pktMulticastSent,',');
 
354
      if(checkFilter(filter, &filterPattern, "bytesMulticastSent")) wrtLlongItm(lang, "\t", "bytesMulticastSent",  el->bytesMulticastSent,',');
 
355
      if(checkFilter(filter, &filterPattern, "pktMulticastRcvd")) wrtLlongItm(lang, "\t", "pktMulticastRcvd",    el->pktMulticastRcvd,',');
 
356
      if(checkFilter(filter, &filterPattern, "bytesSent")) wrtLlongItm(lang, "\t", "bytesSent",           el->bytesSent,',');
 
357
      if(checkFilter(filter, &filterPattern, "bytesSentLocally")) wrtLlongItm(lang, "\t", "bytesSentLocally",    el->bytesSentLocally,',');
 
358
      if(checkFilter(filter, &filterPattern, "bytesSentRemotely")) wrtLlongItm(lang, "\t", "bytesSentRemotely",   el->bytesSentRemotely,',');
 
359
      if(checkFilter(filter, &filterPattern, "bytesReceived")) wrtLlongItm(lang, "\t", "bytesReceived",       el->bytesReceived,',');
 
360
      if(checkFilter(filter, &filterPattern, "bytesReceivedLocally")) wrtLlongItm(lang, "\t", "bytesReceivedLocally", el->bytesReceivedLocally,',');
 
361
      if(checkFilter(filter, &filterPattern, "bytesReceivedFromRemote")) wrtLlongItm(lang, "\t", "bytesReceivedFromRemote",
 
362
                                                               el->bytesReceivedFromRemote,',');
 
363
      if(checkFilter(filter, &filterPattern, "actualRcvdThpt")) wrtFloatItm(lang, "\t", "actualRcvdThpt",    el->actualRcvdThpt,',');
 
364
      if(checkFilter(filter, &filterPattern, "lastHourRcvdThpt")) wrtFloatItm(lang, "\t", "lastHourRcvdThpt",  el->lastHourRcvdThpt,',');
 
365
      if(checkFilter(filter, &filterPattern, "averageRcvdThpt")) wrtFloatItm(lang, "\t", "averageRcvdThpt",   el->averageRcvdThpt,',');
 
366
      if(checkFilter(filter, &filterPattern, "peakRcvdThpt")) wrtFloatItm(lang, "\t", "peakRcvdThpt",      el->peakRcvdThpt,',');
 
367
      if(checkFilter(filter, &filterPattern, "actualSentThpt")) wrtFloatItm(lang, "\t", "actualSentThpt",    el->actualSentThpt,',');
 
368
      if(checkFilter(filter, &filterPattern, "lastHourSentThpt")) wrtFloatItm(lang, "\t", "lastHourSentThpt",  el->lastHourSentThpt,',');
 
369
      if(checkFilter(filter, &filterPattern, "averageSentThpt")) wrtFloatItm(lang, "\t", "averageSentThpt",   el->averageSentThpt,',');
 
370
      if(checkFilter(filter, &filterPattern, "peakSentThpt")) wrtFloatItm(lang, "\t", "peakSentThpt",      el->peakSentThpt,',');
 
371
      if(checkFilter(filter, &filterPattern, "actualRcvdPktThpt")) wrtFloatItm(lang, "\t", "actualRcvdPktThpt", el->actualRcvdPktThpt,',');
 
372
      if(checkFilter(filter, &filterPattern, "averageRcvdPktThpt")) wrtFloatItm(lang, "\t", "averageRcvdPktThpt",el->averageRcvdPktThpt,',');
 
373
      if(checkFilter(filter, &filterPattern, "peakRcvdPktThpt")) wrtFloatItm(lang, "\t", "peakRcvdPktThpt",   el->peakRcvdPktThpt,',');
 
374
      if(checkFilter(filter, &filterPattern, "actualSentPktThpt")) wrtFloatItm(lang, "\t", "actualSentPktThpt", el->actualSentPktThpt,',');
 
375
      if(checkFilter(filter, &filterPattern, "averageSentPktThpt")) wrtFloatItm(lang, "\t", "averageSentPktThpt", el->averageSentPktThpt,',');
 
376
 
 
377
      if(checkFilter(filter, &filterPattern, "ipBytesSent")) wrtLlongItm(lang, "\t", "ipBytesSent", el->ipBytesSent,',');
 
378
      if(checkFilter(filter, &filterPattern, "ipBytesReceived")) wrtLlongItm(lang, "\t", "ipBytesReceived", el->ipBytesReceived,',');
 
379
 
 
380
      if(checkFilter(filter, &filterPattern, "tcpSentRemotely")) wrtLlongItm(lang, "\t", "tcpSentRemotely", el->tcpSentRemotely,',');
 
381
      if(checkFilter(filter, &filterPattern, "udpSentLocally")) wrtLlongItm(lang, "\t", "udpSentLocally", el->udpSentLocally,',');
 
382
      if(checkFilter(filter, &filterPattern, "udpSentRemotely")) wrtLlongItm(lang, "\t", "udpSentRemotely", el->udpSentRemotely,',');
 
383
      if(checkFilter(filter, &filterPattern, "icmpSent")) wrtLlongItm(lang, "\t", "icmpSent",          el->icmpSent,',');
 
384
      if(checkFilter(filter, &filterPattern, "ospfSent")) wrtLlongItm(lang, "\t", "ospfSent",          el->ospfSent,',');
 
385
      if(checkFilter(filter, &filterPattern, "igmpSent")) wrtLlongItm(lang, "\t", "igmpSent",          el->igmpSent,',');
 
386
      if(checkFilter(filter, &filterPattern, "tcpReceivedLocally")) wrtLlongItm(lang, "\t", "tcpReceivedLocally",el->tcpReceivedLocally,',');
 
387
      if(checkFilter(filter, &filterPattern, "tcpReceivedFromRemote")) wrtLlongItm(lang, "\t", "tcpReceivedFromRemote",el->tcpReceivedFromRemote,',');
 
388
      if(checkFilter(filter, &filterPattern, "udpReceivedLocally")) wrtLlongItm(lang, "\t", "udpReceivedLocally",el->udpReceivedLocally,',');
 
389
      if(checkFilter(filter, &filterPattern, "udpReceivedFromRemote")) wrtLlongItm(lang, "\t", "udpReceivedFromRemote",el->udpReceivedFromRemote,',');
 
390
      if(checkFilter(filter, &filterPattern, "icmpReceived")) wrtLlongItm(lang, "\t", "icmpReceived",      el->icmpReceived,',');
 
391
      if(checkFilter(filter, &filterPattern, "ospfReceived")) wrtLlongItm(lang, "\t", "ospfReceived",      el->ospfReceived,',');
 
392
      if(checkFilter(filter, &filterPattern, "igmpReceived")) wrtLlongItm(lang, "\t", "igmpReceived",      el->igmpReceived,',');
 
393
 
 
394
      /* ***************************** */
 
395
 
 
396
      if(checkFilter(filter, &filterPattern, "tcpFragmentsSent")) wrtLlongItm(lang, "\t", "tcpFragmentsSent", el->tcpFragmentsSent,',');
 
397
      if(checkFilter(filter, &filterPattern, "tcpFragmentsReceived")) wrtLlongItm(lang, "\t", "tcpFragmentsReceived", el->tcpFragmentsReceived,',');
 
398
      if(checkFilter(filter, &filterPattern, "udpFragmentsSent")) wrtLlongItm(lang, "\t", "udpFragmentsSent", el->udpFragmentsSent,',');
 
399
      if(checkFilter(filter, &filterPattern, "udpFragmentsReceived")) wrtLlongItm(lang, "\t", "udpFragmentsReceived", el->udpFragmentsReceived,',');
 
400
      if(checkFilter(filter, &filterPattern, "icmpFragmentsSent")) wrtLlongItm(lang, "\t", "icmpFragmentsSent", el->icmpFragmentsSent,',');
 
401
      if(checkFilter(filter, &filterPattern, "icmpFragmentsReceived")) wrtLlongItm(lang, "\t", "icmpFragmentsReceived", el->icmpFragmentsReceived,',');
 
402
 
 
403
      /* ***************************** */
 
404
 
 
405
      if(checkFilter(filter, &filterPattern, "stpSent")) wrtLlongItm(lang, "\t", "stpSent",          el->stpSent,',');
 
406
      if(checkFilter(filter, &filterPattern, "stpReceived")) wrtLlongItm(lang, "\t", "stpReceived",      el->stpReceived,',');
 
407
      if(checkFilter(filter, &filterPattern, "ipxSent")) wrtLlongItm(lang, "\t", "ipxSent",          el->ipxSent,',');
 
408
      if(checkFilter(filter, &filterPattern, "ipxReceived")) wrtLlongItm(lang, "\t", "ipxReceived",      el->ipxReceived,',');
 
409
      if(checkFilter(filter, &filterPattern, "osiSent")) wrtLlongItm(lang, "\t", "osiSent",          el->osiSent,',');
 
410
      if(checkFilter(filter, &filterPattern, "osiReceived")) wrtLlongItm(lang, "\t", "osiReceived",      el->osiReceived,',');
 
411
      if(checkFilter(filter, &filterPattern, "dlcSent")) wrtLlongItm(lang, "\t", "dlcSent",          el->dlcSent,',');
 
412
      if(checkFilter(filter, &filterPattern, "dlcReceived")) wrtLlongItm(lang, "\t", "dlcReceived",      el->dlcReceived,',');
 
413
      if(checkFilter(filter, &filterPattern, "arp_rarpSent")) wrtLlongItm(lang, "\t", "arp_rarpSent",     el->arp_rarpSent,',');
 
414
      if(checkFilter(filter, &filterPattern, "arp_rarpReceived")) wrtLlongItm(lang, "\t", "arp_rarpReceived", el->arp_rarpReceived,',');
 
415
      if(checkFilter(filter, &filterPattern, "arpReqPktsSent")) wrtLlongItm(lang, "\t", "arpReqPktsSent",   el->arpReqPktsSent,',');
 
416
      if(checkFilter(filter, &filterPattern, "arpReplyPktsSent")) wrtLlongItm(lang, "\t", "arpReplyPktsSent", el->arpReplyPktsSent,',');
 
417
      if(checkFilter(filter, &filterPattern, "arpReplyPktsRcvd")) wrtLlongItm(lang, "\t", "arpReplyPktsRcvd", el->arpReplyPktsRcvd,',');
 
418
      if(checkFilter(filter, &filterPattern, "decnetSent")) wrtLlongItm(lang, "\t", "decnetSent",       el->decnetSent,',');
 
419
      if(checkFilter(filter, &filterPattern, "decnetReceived")) wrtLlongItm(lang, "\t", "decnetReceived",   el->decnetReceived,',');
 
420
      if(checkFilter(filter, &filterPattern, "appletalkSent")) wrtLlongItm(lang, "\t", "appletalkSent",    el->appletalkSent,',');
 
421
      if(checkFilter(filter, &filterPattern, "appletalkReceived")) wrtLlongItm(lang, "\t", "appletalkReceived",el->appletalkReceived,',');
 
422
      if(checkFilter(filter, &filterPattern, "netbiosSent")) wrtLlongItm(lang, "\t", "netbiosSent",      el->netbiosSent,',');
 
423
      if(checkFilter(filter, &filterPattern, "netbiosReceived")) wrtLlongItm(lang, "\t", "netbiosReceived",  el->netbiosReceived,',');
 
424
      if(checkFilter(filter, &filterPattern, "qnxSent")) wrtLlongItm(lang, "\t", "qnxSent",          el->qnxSent,',');
 
425
      if(checkFilter(filter, &filterPattern, "qnxReceived")) wrtLlongItm(lang, "\t", "qnxReceived",      el->qnxReceived,',');
 
426
      if(checkFilter(filter, &filterPattern, "otherSent")) wrtLlongItm(lang, "\t", "otherSent",        el->otherSent,',');
 
427
      if(checkFilter(filter, &filterPattern, "otherReceived")) wrtLlongItm(lang, "\t", "otherReceived",    el->otherReceived,',');
 
428
 
 
429
      /* ********************************* */
 
430
 
 
431
      if(el->routedTraffic && checkFilter(filter, &filterPattern, "RoutingCounter")) {
 
432
        initWriteKey(lang, "\t", "RoutingCounter");
 
433
        wrtLlongItm(lang,"\t\t", "routedPkts", el->routedTraffic->routedPkts,',');
 
434
        wrtLlongItm(lang,"\t\t", "routedBytes", el->routedTraffic->routedBytes,',');
 
435
        endWriteKey(lang,"\t",',');
 
436
      }
 
437
 
 
438
      if(el->protoIPTrafficInfos && checkFilter(filter, &filterPattern, "IP")) {
 
439
        initWriteKey(lang, "\t", "IP");
 
440
 
 
441
        for(j=0; j<numIpProtosToMonitor; j++) {
 
442
 
 
443
          if(j > 0) { endWriteKey(lang,"\t\t",','); }
 
444
 
 
445
          initWriteKey(lang, "\t\t", protoIPTrafficInfos[j]);
 
446
          wrtLlongItm(lang,"\t\t\t","sentLocally",
 
447
                      el->protoIPTrafficInfos[j].sentLocally,',');
 
448
          wrtLlongItm(lang,"\t\t\t","sentRemotely",
 
449
                      el->protoIPTrafficInfos[j].sentRemotely,',');
 
450
          wrtLlongItm(lang,"\t\t\t","receivedLocally",
 
451
                      el->protoIPTrafficInfos[j].receivedLocally,',');
 
452
          wrtLlongItm(lang,"\t\t\t","receivedFromRemote",
 
453
                      el->protoIPTrafficInfos[j].receivedFromRemote,' ');
 
454
        }
 
455
        endWriteKey(lang,"\t\t",',');
 
456
        endWriteKey(lang,"\t",',');
 
457
      }
 
458
 
 
459
      /* ***************************************** */
 
460
 
 
461
      if(el->icmpInfo && checkFilter(filter, &filterPattern, "ICMP")) {
 
462
        initWriteKey(lang, "\t", "ICMP");
 
463
        wrtUlongItm(lang,"\t\t","SENT_ECHO",
 
464
                    el->icmpInfo->icmpMsgSent[ICMP_ECHO],' ');
 
465
        wrtUlongItm(lang,"\t\t","SENT_ECHOREPLY",
 
466
                    el->icmpInfo->icmpMsgSent[ICMP_ECHOREPLY],' ');
 
467
        wrtUlongItm(lang,"\t\t","SENT_UNREACH",
 
468
                    el->icmpInfo->icmpMsgSent[ICMP_UNREACH],' ');
 
469
        wrtUlongItm(lang,"\t\t","SENT_ROUTERADVERT",
 
470
                    el->icmpInfo->icmpMsgSent[ICMP_ROUTERADVERT],' ');
 
471
        wrtUlongItm(lang,"\t\t","SENT_TMXCEED",
 
472
                    el->icmpInfo->icmpMsgSent[ICMP_TIMXCEED],' ');
 
473
        wrtUlongItm(lang,"\t\t","SENT_PARAMPROB",
 
474
                    el->icmpInfo->icmpMsgSent[ICMP_PARAMPROB],' ');
 
475
        wrtUlongItm(lang,"\t\t","SENT_MASKREPLY",
 
476
                    el->icmpInfo->icmpMsgSent[ICMP_MASKREPLY],' ');
 
477
        wrtUlongItm(lang,"\t\t","SENT_MASKREQ",
 
478
                    el->icmpInfo->icmpMsgSent[ICMP_MASKREQ],' ');
 
479
        wrtUlongItm(lang,"\t\t","SENT_INFO_REQUEST",
 
480
                    el->icmpInfo->icmpMsgSent[ICMP_INFO_REQUEST],' ');
 
481
        wrtUlongItm(lang,"\t\t","SENT_INFO_REPLY",
 
482
                    el->icmpInfo->icmpMsgSent[ICMP_INFO_REPLY],' ');
 
483
        wrtUlongItm(lang,"\t\t","SENT_TIMESTAMP",
 
484
                    el->icmpInfo->icmpMsgSent[ICMP_TIMESTAMP],' ');
 
485
        wrtUlongItm(lang,"\t\t","SENT_TIMESTAMPREPLY",
 
486
                    el->icmpInfo->icmpMsgSent[ICMP_TIMESTAMPREPLY],' ');
 
487
        wrtUlongItm(lang,"\t\t","SENT_SOURCE_QUENCH",
 
488
                    el->icmpInfo->icmpMsgSent[ICMP_SOURCE_QUENCH],' ');
 
489
 
 
490
        /* *********************************************** */
 
491
 
 
492
        wrtUlongItm(lang,"\t\t","RCVD_ECHO",
 
493
                    el->icmpInfo->icmpMsgRcvd[ICMP_ECHO],' ');
 
494
        wrtUlongItm(lang,"\t\t","RCVD_ECHOREPLY",
 
495
                    el->icmpInfo->icmpMsgRcvd[ICMP_ECHOREPLY],' ');
 
496
        wrtUlongItm(lang,"\t\t","RCVD_UNREACH",
 
497
                    el->icmpInfo->icmpMsgRcvd[ICMP_UNREACH],' ');
 
498
        wrtUlongItm(lang,"\t\t","RCVD_ROUTERADVERT",
 
499
                    el->icmpInfo->icmpMsgRcvd[ICMP_ROUTERADVERT],' ');
 
500
        wrtUlongItm(lang,"\t\t","RCVD_TMXCEED",
 
501
                    el->icmpInfo->icmpMsgRcvd[ICMP_TIMXCEED],' ');
 
502
        wrtUlongItm(lang,"\t\t","RCVD_PARAMPROB",
 
503
                    el->icmpInfo->icmpMsgRcvd[ICMP_PARAMPROB],' ');
 
504
        wrtUlongItm(lang,"\t\t","RCVD_MASKREPLY",
 
505
                    el->icmpInfo->icmpMsgRcvd[ICMP_MASKREPLY],' ');
 
506
        wrtUlongItm(lang,"\t\t","RCVD_MASKREQ",
 
507
                    el->icmpInfo->icmpMsgRcvd[ICMP_MASKREQ],' ');
 
508
        wrtUlongItm(lang,"\t\t","RCVD_INFO_REQUEST",
 
509
                    el->icmpInfo->icmpMsgRcvd[ICMP_INFO_REQUEST],' ');
 
510
        wrtUlongItm(lang,"\t\t","RCVD_INFO_REPLY",
 
511
                    el->icmpInfo->icmpMsgRcvd[ICMP_INFO_REPLY],' ');
 
512
        wrtUlongItm(lang,"\t\t","RCVD_TIMESTAMP",
 
513
                    el->icmpInfo->icmpMsgRcvd[ICMP_TIMESTAMP],' ');
 
514
        wrtUlongItm(lang,"\t\t","RCVD_TIMESTAMPREPLY",
 
515
                    el->icmpInfo->icmpMsgRcvd[ICMP_TIMESTAMPREPLY],' ');
 
516
        wrtUlongItm(lang,"\t\t","RCVD_SOURCE_QUENCH",
 
517
                    el->icmpInfo->icmpMsgRcvd[ICMP_SOURCE_QUENCH],' ');
 
518
 
 
519
        endWriteKey(lang,"\t",',');
 
520
      }
 
521
 
 
522
      /* ********************************* */
 
523
 
 
524
      if(el->securityHostPkts && checkFilter(filter, &filterPattern, "securityPkts")) {
 
525
        initWriteKey(lang, "\t", "securityPkts");
 
526
 
 
527
        wrtLlongItm(lang,"\t\t","synPktsSent",
 
528
                    el->securityHostPkts->synPktsSent.value,',');
 
529
        wrtLlongItm(lang,"\t\t","synPktsRcvd",
 
530
                    el->securityHostPkts->synPktsRcvd.value,',');
 
531
 
 
532
        wrtLlongItm(lang,"\t\t","rstPktsSent",
 
533
                    el->securityHostPkts->rstPktsSent.value,',');
 
534
        wrtLlongItm(lang,"\t\t","rstPktsRcvd",
 
535
                    el->securityHostPkts->rstPktsRcvd.value,',');
 
536
 
 
537
        wrtLlongItm(lang,"\t\t","rstAckPktsSent",
 
538
                    el->securityHostPkts->rstAckPktsSent.value,',');
 
539
        wrtLlongItm(lang,"\t\t","rstAckPktsRcvd",
 
540
                    el->securityHostPkts->rstAckPktsRcvd.value,',');
 
541
 
 
542
        wrtLlongItm(lang,"\t\t","synFinPktsSent",
 
543
                    el->securityHostPkts->synFinPktsSent.value,',');
 
544
        wrtLlongItm(lang,"\t\t","synFinPktsRcvd",
 
545
                    el->securityHostPkts->synFinPktsRcvd.value,',');
 
546
 
 
547
        wrtLlongItm(lang,"\t\t","finPushUrgPktsSent",
 
548
                    el->securityHostPkts->finPushUrgPktsSent.value,',');
 
549
        wrtLlongItm(lang,"\t\t","finPushUrgPktsRcvd",
 
550
                    el->securityHostPkts->finPushUrgPktsRcvd.value,',');
 
551
 
 
552
        wrtLlongItm(lang,"\t\t","nullPktsSent",
 
553
                    el->securityHostPkts->nullPktsSent.value,',');
 
554
        wrtLlongItm(lang,"\t\t","nullPktsRcvd",
 
555
                    el->securityHostPkts->nullPktsRcvd.value,',');
 
556
 
 
557
        wrtLlongItm(lang,"\t\t","ackScanSent",
 
558
                    el->securityHostPkts->ackScanSent.value,',');
 
559
        wrtLlongItm(lang,"\t\t","ackScanRcvd",
 
560
                    el->securityHostPkts->ackScanRcvd.value,',');
 
561
 
 
562
        wrtLlongItm(lang,"\t\t","xmasScanSent",
 
563
                    el->securityHostPkts->xmasScanSent.value,',');
 
564
        wrtLlongItm(lang,"\t\t","xmasScanRcvd",
 
565
                    el->securityHostPkts->xmasScanRcvd.value,',');
 
566
 
 
567
        wrtLlongItm(lang,"\t\t","finScanSent",
 
568
                    el->securityHostPkts->finScanSent.value,',');
 
569
        wrtLlongItm(lang,"\t\t","finScanRcvd",
 
570
                    el->securityHostPkts->finScanRcvd.value,',');
 
571
 
 
572
        wrtLlongItm(lang,"\t\t","nullScanSent",
 
573
                    el->securityHostPkts->nullScanSent.value,',');
 
574
        wrtLlongItm(lang,"\t\t","nullScanRcvd",
 
575
                    el->securityHostPkts->nullScanRcvd.value,',');
 
576
 
 
577
        wrtLlongItm(lang,"\t\t","rejectedTCPConnSent",
 
578
                    el->securityHostPkts->rejectedTCPConnSent.value,',');
 
579
        wrtLlongItm(lang,"\t\t","rejectedTCPConnRcvd",
 
580
                    el->securityHostPkts->rejectedTCPConnRcvd.value,',');
 
581
 
 
582
        wrtLlongItm(lang,"\t\t","establishedTCPConnSent",
 
583
                    el->securityHostPkts->establishedTCPConnSent.value,',');
 
584
        wrtLlongItm(lang,"\t\t","establishedTCPConnRcvd",
 
585
                    el->securityHostPkts->establishedTCPConnRcvd.value,',');
 
586
 
 
587
        wrtLlongItm(lang,"\t\t","udpToClosedPortSent",
 
588
                    el->securityHostPkts->udpToClosedPortSent.value,',');
 
589
        wrtLlongItm(lang,"\t\t","udpToClosedPortRcvd",
 
590
                    el->securityHostPkts->udpToClosedPortRcvd.value,',');
 
591
 
 
592
        wrtLlongItm(lang,"\t\t","udpToDiagnosticPortSent",
 
593
                    el->securityHostPkts->udpToDiagnosticPortSent.value,',');
 
594
        wrtLlongItm(lang,"\t\t","udpToDiagnosticPortRcvd",
 
595
                    el->securityHostPkts->udpToDiagnosticPortRcvd.value,',');
 
596
 
 
597
        wrtLlongItm(lang,"\t\t","tcpToDiagnosticPortSent",
 
598
                    el->securityHostPkts->tcpToDiagnosticPortSent.value,',');
 
599
        wrtLlongItm(lang,"\t\t","tcpToDiagnosticPortRcvd",
 
600
                    el->securityHostPkts->tcpToDiagnosticPortRcvd.value,',');
 
601
 
 
602
        wrtLlongItm(lang,"\t\t","tinyFragmentSent",
 
603
                    el->securityHostPkts->tinyFragmentSent.value,',');
 
604
        wrtLlongItm(lang,"\t\t","tinyFragmentRcvd",
 
605
                    el->securityHostPkts->tinyFragmentRcvd.value,',');
 
606
 
 
607
        wrtLlongItm(lang,"\t\t","icmpFragmentSent",
 
608
                    el->securityHostPkts->icmpFragmentSent.value,',');
 
609
        wrtLlongItm(lang,"\t\t","icmpFragmentRcvd",
 
610
                    el->securityHostPkts->icmpFragmentRcvd.value,',');
 
611
 
 
612
        wrtLlongItm(lang,"\t\t","overlappingFragmentSent",
 
613
                    el->securityHostPkts->overlappingFragmentSent.value,',');
 
614
        wrtLlongItm(lang,"\t\t","overlappingFragmentRcvd",
 
615
                    el->securityHostPkts->overlappingFragmentRcvd.value,',');
 
616
 
 
617
        wrtLlongItm(lang,"\t\t","closedEmptyTCPConnSent",
 
618
                    el->securityHostPkts->closedEmptyTCPConnSent.value,',');
 
619
        wrtLlongItm(lang,"\t\t","closedEmptyTCPConnRcvd",
 
620
                    el->securityHostPkts->closedEmptyTCPConnRcvd.value,',');
 
621
 
 
622
        wrtLlongItm(lang,"\t\t","icmpPortUnreachSent",
 
623
                    el->securityHostPkts->icmpPortUnreachSent.value,',');
 
624
        wrtLlongItm(lang,"\t\t","icmpPortUnreachRcvd",
 
625
                    el->securityHostPkts->icmpPortUnreachRcvd.value,',');
 
626
 
 
627
        wrtLlongItm(lang,"\t\t","icmpHostNetUnreachSent",
 
628
                    el->securityHostPkts->icmpHostNetUnreachSent.value,',');
 
629
        wrtLlongItm(lang,"\t\t","icmpHostNetUnreachRcvd",
 
630
                    el->securityHostPkts->icmpHostNetUnreachRcvd.value,',');
 
631
 
 
632
        wrtLlongItm(lang,"\t\t","icmpProtocolUnreachSent",
 
633
                    el->securityHostPkts->icmpProtocolUnreachSent.value,',');
 
634
        wrtLlongItm(lang,"\t\t","icmpProtocolUnreachRcvd",
 
635
                    el->securityHostPkts->icmpProtocolUnreachRcvd.value,',');
 
636
 
 
637
        wrtLlongItm(lang,"\t\t","icmpAdminProhibitedSent",
 
638
                    el->securityHostPkts->icmpAdminProhibitedSent.value,',');
 
639
        wrtLlongItm(lang,"\t\t","icmpAdminProhibitedRcvd",
 
640
                    el->securityHostPkts->icmpAdminProhibitedRcvd.value,',');
 
641
 
 
642
        wrtLlongItm(lang,"\t\t","malformedPktsSent",
 
643
                    el->securityHostPkts->malformedPktsSent.value,',');
 
644
        wrtLlongItm(lang,"\t\t","malformedPktsRcvd",
 
645
                    el->securityHostPkts->malformedPktsRcvd.value,',');
 
646
 
 
647
        endWriteKey(lang,"\t",',');
 
648
      }
 
649
 
 
650
      /* ***************************** */
 
651
 
 
652
      if(checkFilter(filter, &filterPattern, "ethAddressString")) wrtStrItm(lang, "\t", "ethAddressString",el->ethAddressString,' ');
 
653
 
 
654
      numEntries++;
 
655
    }
 
656
  }
 
657
 
 
658
  if(numEntries > 0) endWriteKey(lang,"",' ');
 
659
 
 
660
  endWriteArray(lang);
 
661
 
 
662
  if(filterPattern.fastmap)
 
663
    free(filterPattern.fastmap);
 
664
}
 
665
 
 
666
/* ********************************** */
 
667
 
 
668
void dumpNtopHashIndexes(char* options) {
 
669
  unsigned int idx, numEntries=0, lang=DEFAULT_LANGUAGE;
 
670
  HostTraffic *el;
 
671
 
 
672
  if(options != NULL) {
 
673
    /* language=[perl|php] */
 
674
    char *tmpStr, *strtokState;
 
675
 
 
676
    tmpStr = strtok_r(options, "&", &strtokState);
 
677
 
 
678
    while(tmpStr != NULL) {
 
679
      int i=0; int j;
 
680
 
 
681
      while((tmpStr[i] != '\0') &&(tmpStr[i] != '='))
 
682
        i++;
 
683
 
 
684
      if(tmpStr[i] == '=') {
 
685
        tmpStr[i] = 0;
 
686
 
 
687
        if(strcmp(tmpStr, "language") == 0) {
 
688
 
 
689
          lang=DEFAULT_LANGUAGE;
 
690
          for(j=1;j <= NB_LANGUAGES;j++) {
 
691
            if(strcmp(&tmpStr[i+1], languages[j]) == 0)
 
692
              lang = j;
 
693
          }
 
694
        }
 
695
      }
 
696
 
 
697
      tmpStr = strtok_r(NULL, "&", &strtokState);
 
698
    }
 
699
  }
 
700
 
 
701
  initWriteArray(lang);
 
702
 
 
703
  for(idx=1; idx<device[actualDeviceId].actualHashSize; idx++) {
 
704
    if(((el = device[actualReportDeviceId].hash_hostTraffic[idx]) != NULL)
 
705
       &&(broadcastHost(el) == 0)) {
 
706
      char *hostKey;
 
707
 
 
708
      if(el->hostNumIpAddress[0] != '\0')
 
709
        hostKey = el->hostNumIpAddress;
 
710
      else
 
711
        hostKey = el->ethAddressString;
 
712
 
 
713
      wrtIntStrItm( lang, "", idx, hostKey,'\n');
 
714
 
 
715
      numEntries++;
 
716
    }
 
717
  }
 
718
 
 
719
  endWriteArray(lang);
 
720
}
 
721
 
 
722
/* ********************************** */
 
723
 
 
724
void dumpNtopTrafficInfo(char* options) {
 
725
  char intoabuf[32], key[16], localbuf[32], filter[128];
 
726
  int lang=DEFAULT_LANGUAGE, i, num;
 
727
  struct re_pattern_buffer filterPattern;
 
728
 
 
729
  memset(key, 0, sizeof(key));
 
730
  memset(filter, 0, sizeof(filter));
 
731
 
 
732
  if(options != NULL) {
 
733
    /* language=[perl|php] */
 
734
    char *tmpStr, *strtokState;
 
735
 
 
736
    tmpStr = strtok_r(options, "&", &strtokState);
 
737
 
 
738
    while(tmpStr != NULL) {
 
739
      int i=0; int j;
 
740
 
 
741
      while((tmpStr[i] != '\0') &&(tmpStr[i] != '='))
 
742
        i++;
 
743
 
 
744
      if(tmpStr[i] == '=') {
 
745
        tmpStr[i] = 0;
 
746
 
 
747
        if(strcmp(tmpStr, "language") == 0) {
 
748
          lang=DEFAULT_LANGUAGE;
 
749
          for(j=1;j <= NB_LANGUAGES;j++) {
 
750
            if(strcmp(&tmpStr[i+1], languages[j]) == 0)
 
751
              lang = j;
 
752
          }
 
753
        } else if(strcmp(tmpStr, "key") == 0) {
 
754
          strncpy(key, &tmpStr[i+1], sizeof(key));
 
755
        } else if(strcmp(tmpStr, "filter") == 0) {
 
756
          strncpy(filter, &tmpStr[i+1], sizeof(filter));
 
757
        }
 
758
      }
 
759
 
 
760
      tmpStr = strtok_r(NULL, "&", &strtokState);
 
761
    }
 
762
  }
 
763
 
 
764
  if(filter[0] != '\0') {
 
765
    const char *re_err;
 
766
 
 
767
    memset(&filterPattern, 0, sizeof(struct re_pattern_buffer));
 
768
 
 
769
    re_err = (const char *)re_compile_pattern(filter, strlen(filter), &filterPattern);
 
770
    if(re_err) {
 
771
      /* Invalid pattern */
 
772
      filter[0] = '\0';
 
773
    } else {
 
774
      filterPattern.fastmap =(char*)malloc(256);
 
775
 
 
776
      if(re_compile_fastmap(&filterPattern)) {
 
777
        /* Invalid pattern */
 
778
        free(filterPattern.fastmap);
 
779
        filter[0] = '\0';
 
780
      }
 
781
    }
 
782
  }
 
783
 
 
784
  initWriteArray(lang);
 
785
 
 
786
  for(i=0, num=0; i<numDevices; i++) {
 
787
    int j;
 
788
 
 
789
    if(device[i].virtualDevice) continue;
 
790
 
 
791
    if(num > 0) { endWriteKey(lang,"",','); }
 
792
 
 
793
    if((key[0] != '\0') &&(strcmp(key, device[i].name) != 0))
 
794
      continue;
 
795
 
 
796
    initWriteKey(lang, "", device[i].name);
 
797
 
 
798
    if(checkFilter(filter, &filterPattern, "ipdot")) wrtStrItm(lang, "\t", "ipdot", device[i].ipdot,',');
 
799
    if(checkFilter(filter, &filterPattern, "fqdn")) wrtStrItm(lang, "\t", "fqdn", device[i].fqdn,',');
 
800
 
 
801
    snprintf(localbuf, sizeof(localbuf), "%s",
 
802
             _intoa(device[i].network, intoabuf, sizeof(intoabuf)));
 
803
    if(checkFilter(filter, &filterPattern, "network")) wrtStrItm(lang, "\t", "network",  localbuf,',');
 
804
    snprintf(localbuf, sizeof(localbuf), "%s",
 
805
             _intoa(device[i].netmask, intoabuf, sizeof(intoabuf)));
 
806
    if(checkFilter(filter, &filterPattern, "netmask")) wrtStrItm(lang, "\t", "netmask", localbuf,',');
 
807
    snprintf(localbuf, sizeof(localbuf), "%s",
 
808
             _intoa(device[i].ifAddr, intoabuf, sizeof(intoabuf)));
 
809
    if(checkFilter(filter, &filterPattern, "ifAddr")) wrtStrItm(lang, "\t", "ifAddr",  localbuf,',');
 
810
 
 
811
    if(checkFilter(filter, &filterPattern, "started")) wrtTime_tItm(lang, "\t", "started",  device[i].started,' ');
 
812
    if(checkFilter(filter, &filterPattern, "firstpkt")) wrtTime_tItm(lang, "\t", "firstpkt", device[i].firstpkt,' ');
 
813
    if(checkFilter(filter, &filterPattern, "lastpkt")) wrtTime_tItm(lang, "\t", "lastpkt",  device[i].lastpkt,' ');
 
814
    if(checkFilter(filter, &filterPattern, "virtualDevice")) wrtIntItm(lang, "\t", "virtualDevice",(int)device[i].virtualDevice,',');
 
815
    if(checkFilter(filter, &filterPattern, "snaplen")) wrtIntItm(lang, "\t", "snaplen",  device[i].snaplen,',');
 
816
    if(checkFilter(filter, &filterPattern, "datalink")) wrtIntItm(lang, "\t", "datalink", device[i].datalink,',');
 
817
    if(checkFilter(filter, &filterPattern, "filter")) wrtStrItm(lang, "\t", "filter",   device[i].filter ? device[i].filter : "",',');
 
818
    if(checkFilter(filter, &filterPattern, "droppedPkts")) wrtLlongItm(lang, "\t", "droppedPkts",device[i].droppedPkts,',');
 
819
    if(checkFilter(filter, &filterPattern, "ethernetPkts")) wrtLlongItm(lang, "\t", "ethernetPkts",device[i].ethernetPkts,',');
 
820
    if(checkFilter(filter, &filterPattern, "broadcastPkts")) wrtLlongItm(lang, "\t", "broadcastPkts",device[i].broadcastPkts,',');
 
821
    if(checkFilter(filter, &filterPattern, "multicastPkts")) wrtLlongItm(lang, "\t", "multicastPkts",device[i].multicastPkts,',');
 
822
    if(checkFilter(filter, &filterPattern, "ethernetBytes")) wrtLlongItm(lang, "\t", "ethernetBytes",device[i].ethernetBytes,',');
 
823
    if(checkFilter(filter, &filterPattern, "ipBytes")) wrtLlongItm(lang, "\t", "ipBytes",device[i].ipBytes,',');
 
824
    if(checkFilter(filter, &filterPattern, "fragmentedIpBytes")) wrtLlongItm(lang, "\t", "fragmentedIpBytes",device[i].fragmentedIpBytes,',');
 
825
    if(checkFilter(filter, &filterPattern, "tcpBytes")) wrtLlongItm(lang, "\t", "tcpBytes",device[i].tcpBytes,',');
 
826
    if(checkFilter(filter, &filterPattern, "udpBytes")) wrtLlongItm(lang, "\t", "udpBytes",device[i].udpBytes,',');
 
827
    if(checkFilter(filter, &filterPattern, "otherIpBytes")) wrtLlongItm(lang, "\t", "otherIpBytes",device[i].otherIpBytes,',');
 
828
    if(checkFilter(filter, &filterPattern, "icmpBytes")) wrtLlongItm(lang, "\t", "icmpBytes",device[i].icmpBytes,',');
 
829
    if(checkFilter(filter, &filterPattern, "dlcBytes")) wrtLlongItm(lang, "\t", "dlcBytes",device[i].dlcBytes,',');
 
830
    if(checkFilter(filter, &filterPattern, "ipxBytes")) wrtLlongItm(lang, "\t", "ipxBytes",device[i].ipxBytes,',');
 
831
    if(checkFilter(filter, &filterPattern, "stpBytes")) wrtLlongItm(lang, "\t", "stpBytes",device[i].stpBytes,',');
 
832
    if(checkFilter(filter, &filterPattern, "decnetBytes")) wrtLlongItm(lang, "\t", "decnetBytes",device[i].decnetBytes,',');
 
833
    if(checkFilter(filter, &filterPattern, "netbiosBytes")) wrtLlongItm(lang, "\t", "netbiosBytes",device[i].netbiosBytes,',');
 
834
    if(checkFilter(filter, &filterPattern, "arpRarpBytes")) wrtLlongItm(lang, "\t", "arpRarpBytes",device[i].arpRarpBytes,',');
 
835
    if(checkFilter(filter, &filterPattern, "atalkBytes")) wrtLlongItm(lang, "\t", "atalkBytes",device[i].atalkBytes,',');
 
836
    if(checkFilter(filter, &filterPattern, "ospfBytes")) wrtLlongItm(lang, "\t", "ospfBytes",device[i].ospfBytes,',');
 
837
    if(checkFilter(filter, &filterPattern, "egpBytes")) wrtLlongItm(lang, "\t", "egpBytes",device[i].egpBytes,',');
 
838
    if(checkFilter(filter, &filterPattern, "igmpBytes")) wrtLlongItm(lang, "\t", "igmpBytes",device[i].igmpBytes,',');
 
839
    if(checkFilter(filter, &filterPattern, "osiBytes")) wrtLlongItm(lang, "\t", "osiBytes",device[i].osiBytes,',');
 
840
    if(checkFilter(filter, &filterPattern, "qnxBytes")) wrtLlongItm(lang, "\t", "qnxBytes",device[i].qnxBytes,',');
 
841
    if(checkFilter(filter, &filterPattern, "otherBytes")) wrtLlongItm(lang, "\t", "otherBytes",device[i].otherBytes,',');
 
842
    if(checkFilter(filter, &filterPattern, "lastMinEthernetBytes")) wrtLlongItm(lang, "\t", "lastMinEthernetBytes",
 
843
                                                             device[i].lastMinEthernetBytes,',');
 
844
    if(checkFilter(filter, &filterPattern, "lastFiveMinsEthernetBytes")) wrtLlongItm(lang, "\t", "lastFiveMinsEthernetBytes",
 
845
                                                             device[i].lastFiveMinsEthernetBytes,',');
 
846
    if(checkFilter(filter, &filterPattern, "lastMinEthernetPkts")) wrtLlongItm(lang, "\t", "lastMinEthernetPkts",device[i].lastMinEthernetPkts,',');
 
847
    if(checkFilter(filter, &filterPattern, "lastFiveMinsEthernetPkts")) wrtLlongItm(lang, "\t", "lastFiveMinsEthernetPkts",
 
848
                                                             device[i].lastFiveMinsEthernetPkts,',');
 
849
    if(checkFilter(filter, &filterPattern, "upTo64")) wrtLlongItm(lang, "\t", "upTo64",device[i].rcvdPktStats.upTo64,',');
 
850
    if(checkFilter(filter, &filterPattern, "upTo128")) wrtLlongItm(lang, "\t", "upTo128",device[i].rcvdPktStats.upTo128,',');
 
851
    if(checkFilter(filter, &filterPattern, "upTo256")) wrtLlongItm(lang, "\t", "upTo256",device[i].rcvdPktStats.upTo256,',');
 
852
    if(checkFilter(filter, &filterPattern, "upTo512")) wrtLlongItm(lang, "\t", "upTo512",device[i].rcvdPktStats.upTo512,',');
 
853
    if(checkFilter(filter, &filterPattern, "upTo1024")) wrtLlongItm(lang, "\t", "upTo1024",device[i].rcvdPktStats.upTo1024,',');
 
854
    if(checkFilter(filter, &filterPattern, "upTo1518")) wrtLlongItm(lang, "\t", "upTo1518",device[i].rcvdPktStats.upTo1518,',');
 
855
    if(checkFilter(filter, &filterPattern, "above1518")) wrtLlongItm(lang, "\t", "above1518",device[i].rcvdPktStats.above1518,',');
 
856
    if(checkFilter(filter, &filterPattern, "shortest")) wrtLlongItm(lang, "\t", "shortest",device[i].rcvdPktStats.shortest,',');
 
857
    if(checkFilter(filter, &filterPattern, "longest")) wrtLlongItm(lang, "\t", "longest",device[i].rcvdPktStats.longest,',');
 
858
    if(checkFilter(filter, &filterPattern, "badChecksum")) wrtLlongItm(lang, "\t", "badChecksum",device[i].rcvdPktStats.badChecksum,',');
 
859
    if(checkFilter(filter, &filterPattern, "tooLong")) wrtLlongItm(lang, "\t", "tooLong",device[i].rcvdPktStats.tooLong,',');
 
860
    if(checkFilter(filter, &filterPattern, "peakThroughput")) wrtFloatItm(lang, "\t", "peakThroughput",device[i].peakThroughput,',');
 
861
    if(checkFilter(filter, &filterPattern, "actualThpt")) wrtFloatItm(lang, "\t", "actualThpt",device[i].actualThpt,',');
 
862
    if(checkFilter(filter, &filterPattern, "lastMinThpt")) wrtFloatItm(lang, "\t", "lastMinThpt",device[i].lastMinThpt,',');
 
863
    if(checkFilter(filter, &filterPattern, "lastFiveMinsThpt")) wrtFloatItm(lang, "\t", "lastFiveMinsThpt",device[i].lastFiveMinsThpt,',');
 
864
    if(checkFilter(filter, &filterPattern, "peakPacketThroughput")) wrtFloatItm(lang, "\t", "peakPacketThroughput",device[i].peakPacketThroughput,',');
 
865
    if(checkFilter(filter, &filterPattern, "actualPktsThpt")) wrtFloatItm(lang, "\t", "actualPktsThpt",device[i].actualPktsThpt,',');
 
866
    if(checkFilter(filter, &filterPattern, "lastMinPktsThpt")) wrtFloatItm(lang, "\t", "lastMinPktsThpt",device[i].lastMinPktsThpt,',');
 
867
    if(checkFilter(filter, &filterPattern, "lastFiveMinsPktsThpt")) wrtFloatItm(lang, "\t", "lastFiveMinsPktsThpt",device[i].lastFiveMinsPktsThpt,',');
 
868
    if(checkFilter(filter, &filterPattern, "throughput")) wrtLlongItm(lang, "\t", "throughput", device[i].throughput,',');
 
869
    if(checkFilter(filter, &filterPattern, "packetThroughput")) wrtFloatItm(lang, "\t", "packetThroughput",device[i].packetThroughput,',');
 
870
 
 
871
    /* ********************************* */
 
872
 
 
873
    if(checkFilter(filter, &filterPattern, "last60MinutesThpt")) {
 
874
      initWriteKey(lang, "\t", "last60MinutesThpt");
 
875
 
 
876
      for(j=0; j<59; j++) {
 
877
        wrtIntFloatItm(lang,"\t\t",j+1,device[i].last60MinutesThpt[j].trafficValue,',');
 
878
      }
 
879
      wrtIntFloatItm(lang,"\t\t",j+1, device[i].last60MinutesThpt[j].trafficValue,' ');
 
880
      endWriteKey(lang,"\t",',');
 
881
    }
 
882
 
 
883
    /* ********************************* */
 
884
 
 
885
    if(checkFilter(filter, &filterPattern, "last24HoursThpt")) {
 
886
      initWriteKey(lang, "\t", "last24HoursThpt");
 
887
 
 
888
      for(j=0; j<23; j++) {
 
889
        wrtIntFloatItm(lang, "\t\t", j+1, device[i].last24HoursThpt[j].trafficValue,',');
 
890
      }
 
891
      wrtIntFloatItm(lang,"\t\t",j+1,device[i].last24HoursThpt[j].trafficValue,' ');
 
892
      endWriteKey(lang,"\t",',');
 
893
    }
 
894
    /* ********************************* */
 
895
 
 
896
    if(checkFilter(filter, &filterPattern, "last30daysThpt")) {
 
897
      initWriteKey(lang, "\t", "last30daysThpt");
 
898
 
 
899
      for(j=0; j<29; j++) {
 
900
        wrtIntFloatItm(lang,"\t\t",j+1,device[i].last30daysThpt[j],',');
 
901
      }
 
902
      wrtIntFloatItm(lang,"\t\t",j+1,device[i].last30daysThpt[j],' ');
 
903
      endWriteKey(lang,"\t",',');
 
904
    }
 
905
 
 
906
    /* ********************************* */
 
907
 
 
908
    if(checkFilter(filter, &filterPattern, "IP")) {
 
909
      if(device[i].ipProtoStats != NULL) {
 
910
        initWriteKey(lang, "\t", "IP");
 
911
 
 
912
        for(j=0; j<numIpProtosToMonitor; j++) {
 
913
          if(j > 0) endWriteKey(lang, "\t\t",',');
 
914
          initWriteKey(lang, "\t\t", protoIPTrafficInfos[j]);
 
915
          wrtLlongItm(lang,"\t\t\t","local",
 
916
                      device[i].ipProtoStats[j].local,',');
 
917
          wrtLlongItm(lang,"\t\t\t","local2remote",
 
918
                      device[i].ipProtoStats[j].local2remote,',');
 
919
          wrtLlongItm(lang,"\t\t\t","remote2local",
 
920
                      device[i].ipProtoStats[j].remote2local,',');
 
921
          wrtLlongItm(lang,"\t\t\t","remote",
 
922
                      device[i].ipProtoStats[j].remote,' ');
 
923
        }
 
924
        endWriteKey(lang,"\t\t",',');
 
925
        endWriteKey(lang,"\t",',');
 
926
      }
 
927
    }
 
928
 
 
929
    /* ********************************* */
 
930
 
 
931
    if(checkFilter(filter, &filterPattern, "TCPflags")) {
 
932
      initWriteKey(lang, "\t", "TCPflags");
 
933
 
 
934
      wrtLlongItm(lang,"\t\t","numEstablishedTCPConnections",
 
935
                  device[i].numEstablishedTCPConnections,' ');
 
936
 
 
937
      endWriteKey(lang,"\t",',');
 
938
    }
 
939
 
 
940
    /* ********************************* */
 
941
 
 
942
    if(checkFilter(filter, &filterPattern, "tcpLocal")) wrtLlongItm(lang,"\t","tcpLocal",
 
943
                                                            device[i].tcpGlobalTrafficStats.local,',');
 
944
    if(checkFilter(filter, &filterPattern, "tcpLocal2Remote")) wrtLlongItm(lang,"\t","tcpLocal2Remote",
 
945
                                                            device[i].tcpGlobalTrafficStats.local2remote,',');
 
946
    if(checkFilter(filter, &filterPattern, "tcpRemote")) wrtLlongItm(lang,"\t","tcpRemote",
 
947
                                                            device[i].tcpGlobalTrafficStats.remote,',');
 
948
    if(checkFilter(filter, &filterPattern, "tcpRemote2Local")) wrtLlongItm(lang,"\t","tcpRemote2Local",
 
949
                                                            device[i].tcpGlobalTrafficStats.remote2local,',');
 
950
 
 
951
    /* ********************************* */
 
952
 
 
953
    if(checkFilter(filter, &filterPattern, "udpLocal")) wrtLlongItm(lang,"\t","udpLocal",
 
954
                                                            device[i].udpGlobalTrafficStats.local,',');
 
955
    if(checkFilter(filter, &filterPattern, "udpLocal2Remote")) wrtLlongItm(lang,"\t","udpLocal2Remote",
 
956
                                                            device[i].udpGlobalTrafficStats.local2remote,',');
 
957
    if(checkFilter(filter, &filterPattern, "udpRemote")) wrtLlongItm(lang,"\t","udpRemote",
 
958
                                                            device[i].udpGlobalTrafficStats.remote,',');
 
959
    if(checkFilter(filter, &filterPattern, "udpRemote2Local")) wrtLlongItm(lang,"\t","udpRemote2Local",
 
960
                                                            device[i].udpGlobalTrafficStats.remote2local,',');
 
961
 
 
962
    /* ********************************* */
 
963
 
 
964
    if(checkFilter(filter, &filterPattern, "icmpLocal")) wrtLlongItm(lang,"\t","icmpLocal",
 
965
                                                            device[i].icmpGlobalTrafficStats.local,',');
 
966
    if(checkFilter(filter, &filterPattern, "icmpLocal2Remote")) wrtLlongItm(lang,"\t","icmpLocal2Remote",
 
967
                                                            device[i].icmpGlobalTrafficStats.local2remote,',');
 
968
    if(checkFilter(filter, &filterPattern, "icmpRemote")) wrtLlongItm(lang,"\t","icmpRemote",
 
969
                                                            device[i].icmpGlobalTrafficStats.remote,',');
 
970
    if(checkFilter(filter, &filterPattern, "icmpRemote2Local")) wrtLlongItm(lang,"\t","icmpRemote2Local",
 
971
                                                            device[i].icmpGlobalTrafficStats.remote2local,' ');
 
972
    num++;
 
973
  }
 
974
 
 
975
  if(num > 0) endWriteKey(lang,"",' ');
 
976
  endWriteArray(lang);
 
977
 
 
978
  if(filterPattern.fastmap)
 
979
    free(filterPattern.fastmap);
 
980
}
 
981
 
 
982