neuro_m.c

嵌入式RMON,RMON为Remote monitor的缩写,基于SNMP为网络提供主动监控及错误告警,智能交换路由必备协议

/* Beholder RMON ethernet network monitor,Copyright (C) 1993 DNPAP group */
/* See file COPYING 'GNU General Public Licence' for copyright details   */
#include <dnpap.h>
#include <config.h>
#include <mibsup.h>
#include <mibrqs.h>
#include <agent.h>
#include <trap.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <timer.h>

#include "neuro_d.h"
#include "neuro_e.h"
#include "neuro_k.h"
#include "neuro_c.h"
#include "neuro.h"

			

IMPORT BOOLEAN BeholderStrictRMON;


static CHAR MODULE[] =	"neuroControl";


static MIB_LOCAL*	NeuroDataInstance = NULL;

static WORD TotalNrNetworks = 0, RunningNrNetworks = 0;


static BOOLEAN		NeuroMibNext(SNMP_OBJECT* obj, MIB_LOCAL** local, WORD idlen, WORD indexsize);  
static BOOLEAN      NeuroGetFirstNext(NeuroData *data, SNMP_OBJECT *obj, WORD idlen, WORD indexsize, BOOLEAN first);
				
static WORD         NeuroSetId(SNMP_OBJECT* obj, WORD idc, WORD indexsize, LONG c, LONG l, LONG n, LONG i);

static WORD         MibName2ID(LONG* id, CHAR* name, UINT* n);
static WORD 		MibID2String(const LONG* id, UINT nr, CHAR* name, INT maxlen);

static BOOLEAN      NeuroMib2Neuron(NeuroData* net, InOutData* mibinout, LONG n, InOutBatch *batch, InOutput* inout);
static BOOLEAN		NeuroNeuron2Mib(InOutput* inout, LONG n, InOutData *iodata, FLOAT* mibinout);

static FLOAT        NeuroMean(FLOAT value[], LONG nrvalues);
static FLOAT        NeuroHarmonic(FLOAT value[], LONG nrvalues);

static VOID         NeuroMCalcCallback(TIMER_DESCR *timer, ULONG now, VOID *param);

static BOOLEAN      NeuroInitOutput(LONG n, InOutput* inout);

static BOOLEAN 		NeuroAllocBatch(NeuroData *data, LONG size, BOOLEAN reset);

static BOOLEAN      NeuroCheckThresholds(NeuroData* data);



/*  config data  */	     
#define MAXCONFIGNAME       81
#define MAXDATASRCNAME	    81


static SHORT		NrNetworks = 0;
				   


BOOLEAN NeuroMInit(VOID)
{
SHORT NrLayers, NrNeurons, DefaultNrLayers,
      DataSourceSteps, DataSourceAverageMethod;
BOOLEAN DataSourceTrap, DataSourceThresholdCheck;
DOUBLE LearningRate, Momentum, DefaultLearningRate, DefaultMomentum, 
       DataSourceValue, DataSourceThresholdValue;
SNMP_OBJECT obj = { SNMP_PDU_SET, { NMIB_BASE }, NMIB_BASELEN, SNMP_INTEGER, SNMP_VALID };
CHAR configname[MAXCONFIGNAME], *DataSourceName;
SHORT c, l, n, i;

	MessageConfig(NEURO_ERROFFSET, "Neuro");
	
	if (NeuroErrorInit() == FALSE)
		FATAL(MODULE, NEURO_ERRINIT);
		
	if (ConfigGetShort("beholder.neuro.networks", &NrNetworks) == TRUE)
	{
		ConfigGetShort("beholder.neuro.Layers", &DefaultNrLayers);
		ConfigGetDouble("beholder.neuro.rate", &DefaultLearningRate);
		ConfigGetDouble("beholder.neuro.momentum", &DefaultMomentum);
		
		for (c = 1; c <= NrNetworks; c++)
		{
			/*  set Status to SNMP_CREATEREQUEST  */
			obj.Type = SNMP_INTEGER;
			obj.Syntax.LngInt = SNMP_CREATEREQUEST;
			NeuroSetId(&obj, NMIB_STATUS, 1, c, 0, 0, 0);
			if (MibRequest(&obj) != SNMP_NOERROR)
				WARNING(MODULE, NEURO_MCREATE);
				
			/*  set Owner to MODULE  */
			obj.Type = SNMP_OCTETSTR;
			memcpy(obj.Syntax.BufChr, MODULE, sizeof(MODULE));
			obj.SyntaxLen = sizeof(MODULE);
			NeuroSetId(&obj, NMIB_OWNER, 1, c, 0, 0, 0);
			if (MibRequest(&obj) != SNMP_NOERROR)
				WARNING(MODULE, NEURO_MOWNER);

			/*  set NrLayers to config value or default  */				
			obj.Type = SNMP_INTEGER;
			sprintf(configname, "beholder.neuro.layers.%d", c);
			if (ConfigGetShort(configname, &NrLayers) == TRUE)
				obj.Syntax.LngInt = NrLayers;
			else
				obj.Syntax.LngInt = DefaultNrLayers;
			NeuroSetId(&obj, NMIB_NRLAYERS, 1, c, 0, 0, 0);
			if (MibRequest(&obj) != SNMP_NOERROR)
				WARNING(MODULE, NEURO_MNRLAYERS);
				
			/*  set LearningRate to config value or default  */				
			obj.Type = SNMP_INTEGER;
			sprintf(configname, "beholder.neuro.rate.%d", c);
			if (ConfigGetDouble(configname, &LearningRate) == TRUE)
				obj.Syntax.LngInt = (LONG)(FLOAT_SCALE*LearningRate);
			else
				obj.Syntax.LngInt = (LONG)(FLOAT_SCALE*DefaultLearningRate);
			NeuroSetId(&obj, NMIB_LRATE, 1, c, 0, 0, 0);
			if (MibRequest(&obj) != SNMP_NOERROR)
				WARNING(MODULE, NEURO_MLRATE); 
				
			/*  set Momentum to config value or default  */				
			obj.Type = SNMP_INTEGER;
			sprintf(configname, "beholder.neuro.momentum.%d", c);
			if (ConfigGetDouble(configname, &Momentum) == TRUE)
				obj.Syntax.LngInt = (LONG)(FLOAT_SCALE*Momentum);
			else
				obj.Syntax.LngInt = (LONG)(FLOAT_SCALE*DefaultMomentum);
			NeuroSetId(&obj, NMIB_MOMENTUM, 1, c, 0, 0, 0);
			if (MibRequest(&obj) != SNMP_NOERROR)
				WARNING(MODULE, NEURO_MMOMENTUM);
				
			for (l = 1; l <= NrLayers; l++)
			{
				obj.Type = SNMP_INTEGER;
				sprintf(configname, "beholder.neuro.neurons.%d.%d", c, l);
				if (ConfigGetShort(configname, &NrNeurons) == TRUE)
					obj.Syntax.LngInt = NrNeurons;
				else					
				{
					ERROR2(MODULE, NEURO_MNRNEURONS, c, l);
					return FALSE;
				}
				NeuroSetId(&obj, NMIB_NRNEURONS, 2, c, l, 0, 0);
				if (MibRequest(&obj) != SNMP_NOERROR)
					ERROR(MODULE, NEURO_MSETNEURONS);
								
				if (l == 1 || l == NrLayers)
				{
					for (n = 1; n <= NrNeurons; n++)
					{	       
						obj.Type = SNMP_OCTETSTR;
						sprintf(configname, "beholder.neuro.datasource.%d.%d.%d", c, l, n);
						if (ConfigGetString(configname, &DataSourceName) == TRUE)
							MibName2ID(obj.Syntax.BufInt, DataSourceName, &obj.SyntaxLen);
						else
						{
							ERROR3(MODULE, NEURO_MDATASRCNAME, c, l, n);
							return FALSE;
						}
						NeuroSetId(&obj, NMIB_DATASRC, 3, c, l, n, 0);
						if (MibRequest(&obj) != SNMP_NOERROR)
							ERROR(MODULE, NEURO_MSETDATASRC);
						
						obj.Type = SNMP_INTEGER;
						sprintf(configname, "beholder.neuro.datasource.max.%d.%d.%d", c, l, n);
						if (ConfigGetDouble(configname, &DataSourceValue) == TRUE)
							obj.Syntax.LngInt = (LONG)(FLOAT_SCALE*DataSourceValue);
						else
						{
							ERROR3(MODULE, NEURO_MDATASRCMAX, c, l, n);
							return FALSE;
						}		     
						NeuroSetId(&obj, NMIB_DATASRCMAX, 3, c, l, n, 0);
						if (MibRequest(&obj) != SNMP_NOERROR)
							ERROR(MODULE, NEURO_MSETDATASRCMAX);
						
						obj.Type = SNMP_INTEGER;
						sprintf(configname, "beholder.neuro.datasource.min.%d.%d.%d", c, l, n);
						if (ConfigGetDouble(configname, &DataSourceValue) == TRUE)
							obj.Syntax.LngInt = (LONG)(FLOAT_SCALE*DataSourceValue);
						else
						{
							ERROR3(MODULE, NEURO_MDATASRCMIN, c, l, n);
							return FALSE;
						}		     
						NeuroSetId(&obj, NMIB_DATASRCMIN, 3, c, l, n, 0);
						if (MibRequest(&obj) != SNMP_NOERROR)
							ERROR(MODULE, NEURO_MSETDATASRCMIN);
											       
						obj.Type = SNMP_INTEGER;
						sprintf(configname, "beholder.neuro.datasource.method.%d.%d.%d", c, l, n);
						if (ConfigGetShort(configname, &DataSourceAverageMethod) == TRUE)
							obj.Syntax.LngInt = DataSourceAverageMethod;
						else
						{
							ERROR3(MODULE, NEURO_MDATASRCAVERAGEMETHOD, c, l, n);
							return FALSE;
						}		     
						NeuroSetId(&obj, NMIB_DATASRCAVERAGEMETHOD, 3, c, l, n, 0);
						if (MibRequest(&obj) != SNMP_NOERROR)
							ERROR(MODULE, NEURO_MSETDATASRCAVERAGEMETHOD);
							
						obj.Type = SNMP_INTEGER;
						sprintf(configname, "beholder.neuro.datasource.steps.%d.%d.%d", c, l, n);
						if (ConfigGetShort(configname, &DataSourceSteps) == TRUE)
							obj.Syntax.LngInt = DataSourceSteps;
						else
						{
							ERROR3(MODULE, NEURO_MDATASRCSTEPS, c, l, n);
							return FALSE;
						}		     
						NeuroSetId(&obj, NMIB_DATASRCSTEPS, 3, c, l, n, 0);
						if (MibRequest(&obj) != SNMP_NOERROR)
							ERROR(MODULE, NEURO_MSETDATASRCSTEPS);
							
						obj.Type = SNMP_INTEGER;
						sprintf(configname, "beholder.neuro.datasource.trap.%d.%d.%d", c, l, n);
						if (ConfigGetBoolean(configname, &DataSourceTrap) == TRUE)
							obj.Syntax.LngInt = DataSourceTrap;
						else
						{
							ERROR3(MODULE, NEURO_MDATASRCTRAP, c, l, n);
							return FALSE;
						}		     
						NeuroSetId(&obj, NMIB_DATASRCTRAP, 3, c, l, n, 0);
						if (MibRequest(&obj) != SNMP_NOERROR)
							ERROR(MODULE, NEURO_MSETDATASRCTRAP);
							
						obj.Type = SNMP_INTEGER;
						sprintf(configname, "beholder.neuro.datasource.check.%d.%d.%d", c, l, n);
						if (ConfigGetBoolean(configname, &DataSourceThresholdCheck) == TRUE)
							obj.Syntax.LngInt = DataSourceThresholdCheck;
						else
						{
							ERROR3(MODULE, NEURO_MDATASRCCHECK, c, l, n);
							return FALSE;
						}		     
						NeuroSetId(&obj, NMIB_DATASRCTHRESHOLDCHECK, 3, c, l, n, 0);
						if (MibRequest(&obj) != SNMP_NOERROR)
							ERROR(MODULE, NEURO_MSETDATASRCCHECK);
							
						for (i = 0; i < MAXNRTHRESHOLDVALUES; i++)
						{
							obj.Type = SNMP_INTEGER;
							sprintf(configname, "beholder.neuro.datasource.threshold.%d.%d.%d.%d", c, l, n, i);
							if (ConfigGetDouble(configname, &DataSourceThresholdValue) == TRUE)
								obj.Syntax.LngInt = (LONG)(FLOAT_SCALE*DataSourceThresholdValue);
							else
							{
								ERROR4(MODULE, NEURO_MDATASRCTHRESHOLDVALUE, c, l, n, i);
								return FALSE;
							}		     
							NeuroSetId(&obj, NMIB_DATASRCTHRESHOLDVALUE, 4, c, l, n, i);
							if (MibRequest(&obj) != SNMP_NOERROR)
								ERROR(MODULE, NEURO_MSETDATASRCTHRESHOLDVALUE);
						}
					}
				}
			}

		    NeuroSetId(&obj, NMIB_STATUS, 1, c, 0, 0, 0);
    		if (MibRequest(&obj) != SNMP_NOERROR)
	    		WARNING(MODULE, NEURO_MSTART);
		}
	}
	
	return TRUE;
}


BOOLEAN NeuroMibNext(SNMP_OBJECT* obj, MIB_LOCAL** local, WORD idlen, WORD indexsize)
{
BOOLEAN first = FALSE;

    if (*local == NULL || indexsize < 1)
        return FALSE;

	while (*local != NULL && NeuroGetFirstNext((NeuroData *)(*local)->Data, obj, idlen, indexsize, first) == FALSE)
    {
        first = TRUE;
		/* only go to next collector if requested index was higher or equal */
		if (obj->Id[idlen] >= (*local)->Index)
	        *local = (*local)->Next;
    }

    if (*local == NULL)
        return FALSE;
    obj->Id[idlen] = (*local)->Index;
    obj->IdLen = idlen+indexsize;

    return TRUE;
}


BOOLEAN NeuroGetFirstNext(NeuroData *data, SNMP_OBJECT *obj, WORD idlen, WORD indexsize, BOOLEAN first)
{	
LONG layer, neuron, step;
WORD i, len;

    if (first == TRUE)
    {
		for (i = obj->IdLen; i < idlen+indexsize; i++)
    		obj->Id[i] = 1;
		obj->IdLen = idlen+indexsize;
        return TRUE;
	}

    layer = neuron = step = 0;

    len = obj->IdLen-idlen;

    switch (len)
    {
	case NMIB_IOFFSET:
        step = obj->Id[idlen-1+NMIB_IOFFSET];
	case NMIB_NOFFSET:
        neuron = obj->Id[idlen-1+NMIB_NOFFSET];
	case NMIB_LOFFSET:
        layer = obj->Id[idlen-1+NMIB_LOFFSET];
    }

	switch (indexsize)
	{
	case NMIB_IOFFSET:
		/*  layer index must be 1 or NrLayers  */
		if ((layer == 1 || layer == data->NrLayers) &&
            (neuron > 0 && neuron <= data->NrNeurons[layer-1]) &&
			 step < (layer == 1 ? NeuroThresholds(&data->InputData[neuron-1]) : NeuroThresholds(&data->TargetData[neuron-1])))
		{
			step++;
            break;
		}
	case NMIB_NOFFSET:
		/*  layer index must be 1 or NrLayers  */
		if ((layer == 1 || layer == data->NrLayers) &&
            (neuron > 0 && neuron < data->NrNeurons[layer-1]))
		{
			neuron++;
			switch (indexsize)
			{	
			case NMIB_IOFFSET:
				step = 1;
			}
			break;
		}
	case NMIB_LOFFSET:
		if (layer > 0 && layer < data->NrLayers)
		{					   			   
			/*  layer index must be 1 or NrLayers in case   */
			/*  neuron index or subindex must be specified  */
			if (indexsize == NMIB_IOFFSET || indexsize == NMIB_NOFFSET)
				layer = data->NrLayers;
			else
				layer++;
			switch (indexsize)
			{	
			case NMIB_IOFFSET:
                step = 1;
			case NMIB_NOFFSET:
				neuron = 1;
			}
            break;
		}
	case NMIB_COFFSET:
        if (len == 0)
        {
            layer = neuron = step = 1;
            break;
        }
        return FALSE;
	}

    switch (indexsize)
    {
	case NMIB_IOFFSET:
        obj->Id[idlen-1+NMIB_IOFFSET] = step;
	case NMIB_NOFFSET:
        obj->Id[idlen-1+NMIB_NOFFSET] = neuron;
	case NMIB_LOFFSET:
        obj->Id[idlen-1+NMIB_LOFFSET] = layer;
    }

	return TRUE;
}


WORD NeuroNrNetworks(SNMP_OBJECT* obj, WORD idlen)
{
	if (MibSimple(obj, idlen) == FALSE)
	 	return SNMP_NOSUCHNAME;

	switch (obj->Request)
	{
    case SNMP_PDU_NEXT:
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = TotalNrNetworks;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD NeuroRunningNrNetworks(SNMP_OBJECT* obj, WORD idlen)
{
	if (MibSimple(obj, idlen) == FALSE)
	 	return SNMP_NOSUCHNAME;

	switch (obj->Request)
	{
    case SNMP_PDU_NEXT:
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = RunningNrNetworks;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD NeuroIndex(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;

	if ((local = MibRmon(obj, NeuroDataInstance, idlen, 1)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (NeuroMibNext(obj, &local, idlen, 1) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = local->Index;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD NeuroLayerIndex(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
			
	if ((local = MibRmon(obj, NeuroDataInstance, idlen, 2)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (NeuroMibNext(obj, &local, idlen, 2) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = local->Index;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD NeuroLayerIndexLayer(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
			
	if ((local = MibRmon(obj, NeuroDataInstance, idlen, 2)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (NeuroMibNext(obj, &local, idlen, 2) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = obj->Id[idlen-1+NMIB_LOFFSET];
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD NeuroLayerNeuronIndex(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
			
	if ((local = MibRmon(obj, NeuroDataInstance, idlen, 3)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (NeuroMibNext(obj, &local, idlen, 3) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = local->Index;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD NeuroLayerNeuronIndexLayer(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
			
	if ((local = MibRmon(obj, NeuroDataInstance, idlen, 3)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (NeuroMibNext(obj, &local, idlen, 3) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = obj->Id[idlen-1+NMIB_LOFFSET];
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD NeuroLayerNeuronIndexNeuron(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
			
	if ((local = MibRmon(obj, NeuroDataInstance, idlen, 3)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (NeuroMibNext(obj, &local, idlen, 3) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = obj->Id[idlen-1+NMIB_NOFFSET];
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;