/*! \file  bandwidth.c    Copyright 2003-2004 Fraunhofer Institute for Open Communication Systems (FOKUS),                        Berlin, Germany    This file is part of Network Measurement and Accounting System (NETMATE).    NETMATE is free software; you can redistribute it and/or modify     it under the terms of the GNU General Public License as published by     the Free Software Foundation; either version 2 of the License, or    (at your option) any later version.    NETMATE is distributed in the hope that it will be useful,     but WITHOUT ANY WARRANTY; without even the implied warranty of     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    GNU General Public License for more details.    You should have received a copy of the GNU General Public License    along with this software; if not, write to the Free Software     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    Description:    action module for basic accounting plus bandwidth calculation and     intermediate counter logging (writes all collected counters on next export)    $Id: bandwidth.c,v 1.1.1.1 2004/12/23 05:52:36 s_zander Exp $*/#include "config.h"#include <stdio.h>#include "ProcModule.h"#include "arpa/inet.h"#include <sys/types.h>#include <time.h>     const int COUNTCHUNK = 20;    /* new entries per realloc *//*  defines timer for making 'counter snapshot'*/timers_t timers[] = {    /* handle, ival_msec, flags */    {       1,  1000 * 0, TM_RECURRING },    /*         ival == 0 means no timeout between collections by default */    TIMER_END};typeInfo_t exportInfo[] = {     { LIST,   "counters" },    { UINT32, "packets"       },    { UINT32, "bytes"         },    { UINT32, "first_time"    },    { UINT32, "first_time_us" },    { UINT32, "last_time"     },    { UINT32, "last_time_us"  },    { UINT32, "packet_rate"   },    { UINT32, "bandwidth"     },    LIST_END,    EXPORT_END};/* counter snapshot record (one record per snapshot is stored in a list) */typedef struct {    long long packets;    /* number of packets received */    long long bytes;      /* number of bytes received   */    struct timeval first; /* timestamp of first packet received */    struct timeval last;  /* timestamp of last packet received  */    long int packet_bw;   /* bandwidth in packets per second */    long int bandwidth;   /* bandwidth in bytes per second */} measData_t;/* per task flow record information */typedef struct {    long int  export_ts;   /* timestamp of measurement start */    int       numSets;    /* number of records currently stored */    int       maxSets;    /* maximum number of datasets currently storable (without resize) */    measData_t curr;      /* current set of (active) counters for last interval*/    measData_t *dataSets; /* dynamic array for storing intermediate couters */    timers_t currTimers[ sizeof(timers) / sizeof(timers[0]) ];} accData_t;struct timeval zerotime = {0,0};static char* expData;static unsigned int   expDataSize;int initModule(){    expDataSize = sizeof(measData_t) + 20;    expData = (char*) malloc(expDataSize);        return 0;}int destroyModule(){    free( expData );        return 0;}inline void resetCurrent( accData_t *data ){    data->curr.packets = 0;    data->curr.bytes = 0;    data->curr.first = zerotime;    data->curr.last = zerotime;    data->curr.packet_bw = 0;    data->curr.bandwidth = 0;}void appendCounters(accData_t *data ){    if (data->currTimers[0].ival_msec == 0) {	return;    }        if (data->numSets == data->maxSets ) {	/* fprintf( stderr, "allocating %d sets\n", (data->maxSets + COUNTCHUNK) ); */	data->dataSets = (measData_t*) realloc( data->dataSets, (data->maxSets + COUNTCHUNK)*sizeof(measData_t) );	data->maxSets += COUNTCHUNK;     }        /* calculate bandwidth for this collection interval */    data->curr.bandwidth = data->curr.bytes * 1000 / data->currTimers[0].ival_msec;    data->curr.packet_bw = data->curr.packets * 1000 / data->currTimers[0].ival_msec;        memcpy( &(data->dataSets[data->numSets++]), &(data->curr), sizeof(measData_t) );}int processPacket( char *packet, metaData_t *meta, void *flowdata ){    accData_t *data = flowdata;    /* save timestamp from first incoming packet */    if (data->curr.packets == 0) {        data->curr.first.tv_sec = meta->tv_sec;        data->curr.first.tv_usec = meta->tv_usec;    }    /* save timestamp for last incoming packet */    data->curr.last.tv_sec = meta->tv_sec;    data->curr.last.tv_usec = meta->tv_usec;    /* count packets and account packet volume (including link layer) */    data->curr.packets += 1;    data->curr.bytes   += meta->len;    return 0;}int initFlowRec( configParam_t *params, void **flowdata ){    accData_t *data;    data = malloc( sizeof(accData_t) );    if (data == NULL ) {        return -1;    }        data->numSets = 0;    data->maxSets = 0;    data->dataSets = NULL;    data->export_ts = time(NULL);        /* init current block of counters */    resetCurrent( data );    /* copy default timers to current timers array for a specific task */    memcpy(data->currTimers, timers, sizeof(timers));    while (params[0].name != NULL) {        if (!strcmp(params[0].name, "Interval")) {            int a = atoi(params[0].value);            if (a > 0) {                data->currTimers[0].ival_msec = 1000 * a;#ifdef DEBUG		fprintf( stderr, "bandwidth module: setting snapshot timer to %d secs\n", a );#endif            }        }        params++;    }        *flowdata = data;    return 0;}int resetFlowRec( void *flowdata ){    return 0;}int destroyFlowRec( void *flowdata ){  accData_t *data = flowdata;  free( data->dataSets );  free( data );  return 0;}int exportData( void **exp, int *len, void *flowdata ){    accData_t *data = flowdata;    measData_t *curr;    int i;    /* if no intermediate snapshots were taken then only export current pointers */    if (data->numSets == 0) {	long int tstamp = time(NULL);	/* calculate bandwidth for this collection interval */	if (tstamp == data->export_ts) { // avoid division by zero	  data->curr.bandwidth = 0;	  data->curr.packet_bw = 0;	} else {	  data->curr.bandwidth = data->curr.bytes / (tstamp - data->export_ts);	  data->curr.packet_bw = data->curr.packets / (tstamp -data->export_ts);	}	STARTEXPORT(expData);	ADD_LIST(1); /* one row of data */        ADD_UINT32( data->curr.packets       );        ADD_UINT32( data->curr.bytes         );        ADD_UINT32( data->curr.first.tv_sec  );        ADD_UINT32( data->curr.first.tv_usec );        ADD_UINT32( data->curr.last.tv_sec   );        ADD_UINT32( data->curr.last.tv_usec  );        ADD_UINT32( data->curr.packet_bw     );        ADD_UINT32( data->curr.bandwidth     );	END_LIST();	ENDEXPORT( exp, len );	resetCurrent(data);       /* reset counters */	data->export_ts = tstamp; /* remember time of last export */	return 0;    }    /* else export stored snapshots */    if (expDataSize < data->numSets * sizeof(measData_t) + 20) {        expDataSize = data->numSets * sizeof(measData_t) + 20;        expData = (char*) realloc( expData, expDataSize );    }    STARTEXPORT( expData );    ADD_LIST( data->numSets );        curr = data->dataSets;    for( i = 0; i<data->numSets; i++ ) {                ADD_UINT32( curr->packets       );        ADD_UINT32( curr->bytes         );        ADD_UINT32( curr->first.tv_sec  );        ADD_UINT32( curr->first.tv_usec );        ADD_UINT32( curr->last.tv_sec   );        ADD_UINT32( curr->last.tv_usec  );        ADD_UINT32( curr->packet_bw     );        ADD_UINT32( curr->bandwidth     );                curr++;    }    END_LIST();    ENDEXPORT( exp, len );    data->numSets = 0;    return 0;}int dumpData( char *string, void *flowdata ){    return 0;}char* getModuleInfo(int i){    /* fprintf( stderr, "count : getModuleInfo(%d)\n",i ); */    switch(i) {    case I_MODNAME:    return "bandwidth";    case I_VERSION:    return "2.0";    case I_CREATED:    return "2002/12/19";    case I_MODIFIED:   return "2003/09/08";    case I_BRIEF:      return "intermediate accounting (packets+volume) "                         "plus bandwidth calculation";    case I_VERBOSE:    return "count packets, volume, save first and last "                         "time, packet and volume bandwidth";    case I_HTMLDOCS:   return "http://www.fokus.fhg.de/modules/bandwidth.html";    case I_PARAMS:     return "Interval[int] : store counters every [int] "                         "seconds";    case I_RESULTS:    return "results description = ...";    case I_AUTHOR:     return "Carsten Schmoll";    case I_AFFILI:     return "Fraunhofer Institute FOKUS, Germany";    case I_EMAIL:      return "schmoll@fokus.fraunhofer.de";    case I_HOMEPAGE:   return "http://homepage";    default: return NULL;    }}char* getErrorMsg( int code ){    return NULL;}int timeout( int timerID, void *flowdata ){    accData_t *data = (accData_t *)flowdata;#ifdef DEBUG    fprintf( stderr, "bandwidth: timeout(n = %d)\n", timerID );#endif    appendCounters(data);    resetCurrent(data);    return 0;}timers_t* getTimers( void *flowData ){    accData_t *data = (accData_t *)flowData;    /* return timers record if ival > 0, else return "no timers available" (NULL) */    return (data->currTimers[0].ival_msec > 0) ? data->currTimers : NULL;}