discconm.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 <memory.h>
#include <dnpap.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <message.h>
#include <mibsup.h>
#include <mac.h>

#include "discd.h"
#include "disce.h"
#include "discconc.h"
#include "disccon.h"


IMPORT BOOLEAN BeholderStrictRMON;


static MIB_LOCAL    *DiscConnControlInstance = NULL;


static BOOLEAN RmonNext(SNMP_OBJECT *obj, MIB_LOCAL **local, WORD idlen, INT type, WORD indexsize, DISCCONN **elem, BOOLEAN SDorder);
static DISCCONN *SrcDstGetFirstNext(DISCCONN_CONTROL *discconncontrol, INT type, WORD indexsize, SNMP_OBJECT *obj, WORD idlen, BOOLEAN first, BOOLEAN SDorder);

static INT DiscTableType(SNMP_OBJECT *obj, WORD idlen);
static WORD DiscTableLen(INT type, INT addrtype, WORD *offset, WORD *sublen, BOOLEAN sd);



BOOLEAN DiscConnMInit(VOID)
{
    MessageConfig(DISCCONN_ERROR, "DiscConn");
    return DiscConnConfigInit();
}


BOOLEAN RmonNext(SNMP_OBJECT *obj, MIB_LOCAL **local, WORD idlen, INT type, WORD indexsize, DISCCONN **elem, BOOLEAN SDorder)
{
BOOLEAN first = FALSE;

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

    switch (indexsize)
    {            
    case DISC_ETHCONNINDEXSIZE:
    case DISC_IPCONNINDEXSIZE:
    case DISC_UDPCONNINDEXSIZE:
    /*  case DISC_TCPCONNINDEXSIZE:  */
        while (*local != NULL && (*elem = SrcDstGetFirstNext((DISCCONN_CONTROL*)(*local)->Data, type, indexsize, obj, idlen, first, SDorder)) == NULL)
        {
            first = TRUE;
            *local = (*local)->Next;
        }
        if (*local == NULL)
            return FALSE;
        obj->Id[idlen] = (*local)->Index;
        break;
    case CONTROLINDEXSIZE:
	    if (obj->IdLen >= idlen + indexsize)
	    {
			/* 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 + CONTROLINDEXSIZE;
        break;
    }
    return TRUE;
}


DISCCONN *SrcDstGetFirstNext(DISCCONN_CONTROL *discconncontrol, INT type, WORD indexsize, SNMP_OBJECT *obj, WORD idlen, BOOLEAN first, BOOLEAN SDorder)
{
BYTE srcdst[DISC_SIZE_CONN];
DISCCONN *p, *sdlexlist = NULL, *dslexlist = NULL;
INT i, len, addrlen = 0;

    if (discconncontrol->TableSize == 0)
        return NULL;

    switch (type)
    {
    case DISC_TYPE_ETH:
        sdlexlist = discconncontrol->EthSrcDstList;
        dslexlist = discconncontrol->EthSrcDstList;
        addrlen = DISC_SIZE_ETHADDR;
        break;
    case DISC_TYPE_IP:
        sdlexlist = discconncontrol->IPSrcDstList;
        dslexlist = discconncontrol->IPDstSrcList;
        addrlen = DISC_SIZE_TOIPADDR;
        break;
    case DISC_TYPE_UDP:
        sdlexlist = discconncontrol->UDPSrcDstList;
        dslexlist = discconncontrol->UDPDstSrcList;
        addrlen = DISC_SIZE_TOUDPADDR;
        break;
    case DISC_TYPE_TCP:
        sdlexlist = discconncontrol->TCPSrcDstList;
        dslexlist = discconncontrol->TCPDstSrcList;
        addrlen = DISC_SIZE_TOTCPADDR;
        break;
    }

    if (first == TRUE)
	{
        if (SDorder == TRUE)
        {
            p = sdlexlist;
            obj->IdLen = Conn2Id(type, p->SrcDst, 2*addrlen, obj->Id, idlen+1);
            return p;
        }
        else
        {
            p = dslexlist;
            for (i = 0; i < addrlen; i++)
            {
                srcdst[i] = p->SrcDst[addrlen+i];
                srcdst[addrlen+i] = p->SrcDst[i];
            }
            obj->IdLen = Conn2Id(type, srcdst, 2*addrlen, obj->Id, idlen+1);
            return p;
        }
	}

    /*  fill in srcdst in both orders: SDorder or reverse  */
    len = Id2Conn(type, obj->Id, idlen+1, obj->IdLen, srcdst);

    p = DiscConnSearchNext(discconncontrol, type, srcdst, len, SDorder);

    if (p != NULL)
    {
        if (SDorder == TRUE)
            obj->IdLen = Conn2Id(type, p->SrcDst, 2*addrlen, obj->Id, idlen+1);
        else
        {
            for (i = 0; i < addrlen; i++)
            {
                srcdst[i] = p->SrcDst[addrlen+i];
                srcdst[addrlen+i] = p->SrcDst[i];
            }
            obj->IdLen = Conn2Id(type, srcdst, 2*addrlen, obj->Id, idlen+1);
        }
    }
    return p;
}


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

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == 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 DiscConnControlDataSource(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;
MAC_IFACE    *iface;
LONG         IfaceOid[] = {1,3,6,1,2,1,2,2,1,1,1};
WORD         IfaceOidLen = sizeof(IfaceOid)/sizeof(LONG);
LONG         ChannelOid[] = {1,3,6,1,2,1,16,7,2,1,1,1};
WORD         ChannelOidLen = sizeof(ChannelOid)/sizeof(LONG);

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {           
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
		if (BeholderStrictRMON && !BooleanCheck(data->ObjectSet, DISC_BOOLEAN_DATASOURCE))
			return SNMP_NOSUCHNAME;
        memcpy (obj->Syntax.BufInt, data->Source, data->SourceLen*sizeof(data->Source[0]));
        obj->SyntaxLen = data->SourceLen;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
        data = (DISCCONN_CONTROL*) local->Data;
        if (data->Status != SNMP_UNDERCREATION)
            return SNMP_READONLY;
        if (IfaceOidLen == obj->SyntaxLen &&
            memcmp(IfaceOid, obj->Syntax.BufInt, (IfaceOidLen-1)*sizeof(IfaceOid[0])) == 0)
        {
            data->Channel = FALSE;
            if ((iface = MacIfaceGet((WORD) obj->Syntax.BufInt[obj->SyntaxLen-1])) == NULL)
                return SNMP_BADVALUE;
            if (iface->type != MAC_TYPE_ETHERNET_CSMACD && iface->type != MAC_TYPE_88023_CSMACD)
           	    return SNMP_BADVALUE;
            memcpy(data->Source, obj->Syntax.BufInt, obj->SyntaxLen*sizeof(data->Source[0]));
            data->SourceLen = obj->SyntaxLen;
            data->Iface = iface;
			BooleanSetTrue(data->ObjectSet, DISC_BOOLEAN_DATASOURCE);
            return SNMP_NOERROR;
        }
        else
        if (ChannelOidLen == obj->SyntaxLen &&
            memcmp(ChannelOid, obj->Syntax.BufInt, (ChannelOidLen-1)*sizeof(ChannelOid[0])) == 0)
        {                         
            data->Channel = TRUE;
            memcpy(data->Source, obj->Syntax.BufInt, obj->SyntaxLen*sizeof(data->Source[0]));
            data->SourceLen = obj->SyntaxLen;
			BooleanSetTrue(data->ObjectSet, DISC_BOOLEAN_DATASOURCE);
            return SNMP_NOERROR;
        }
        return SNMP_BADVALUE;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlEthTableSize(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngInt = data->EthTableSize;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
    	return SNMP_READONLY;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlIPTableSize(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngInt = data->IPTableSize;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
    	return SNMP_READONLY;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlUDPTableSize(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngInt = data->UDPTableSize;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
    	return SNMP_READONLY;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlTCPTableSize(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngInt = data->TCPTableSize;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
    	return SNMP_READONLY;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlTableSize(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngInt = data->TableSize;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
    	return SNMP_READONLY;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlLastDeleteTime(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngUns = data->LastDeleteTime;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
    	return SNMP_READONLY;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlOwner(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    if ((local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DISCCONN_CONTROL*) local->Data;
		if (BeholderStrictRMON && !BooleanCheck(data->ObjectSet, DISC_BOOLEAN_OWNER))
			return SNMP_NOSUCHNAME;
        memcpy (obj->Syntax.BufChr, data->Owner, data->OwnerLen);
        obj->SyntaxLen = data->OwnerLen;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
        data = (DISCCONN_CONTROL*) local->Data;
        if (data->Status != SNMP_UNDERCREATION)
            return SNMP_READONLY;
        memcpy (data->Owner, obj->Syntax.BufChr, obj->SyntaxLen);
        data->OwnerLen = obj->SyntaxLen;
		BooleanSetTrue(data->ObjectSet, DISC_BOOLEAN_OWNER);
        return SNMP_NOERROR;
    }
    return SNMP_GENERROR;
}


WORD DiscConnControlStatus(SNMP_OBJECT *obj, WORD idlen)
{
MIB_LOCAL    *local = NULL;
DISCCONN_CONTROL *data;

    local = MibRmon(obj, DiscConnControlInstance, idlen, CONTROLINDEXSIZE);

    switch (obj->Request)
    {
    case SNMP_PDU_GET:
        if (local == NULL)
        {
            obj->Syntax.LngInt = SNMP_INVALID;
            return SNMP_NOSUCHNAME;
        }
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngInt = data->Status;
        return SNMP_NOERROR;
    case SNMP_PDU_NEXT:
        if (RmonNext(obj, &local, idlen, 0, CONTROLINDEXSIZE, NULL, FALSE) == FALSE)
        {
            obj->Syntax.LngInt = SNMP_INVALID;
            return SNMP_NOSUCHNAME;
        }
        data = (DISCCONN_CONTROL*) local->Data;
        obj->Syntax.LngInt = data->Status;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
        if (local == NULL)
        {
            switch (obj->Syntax.LngInt)
            {
            case SNMP_CREATEREQUEST:
                if ((local = MibInsert(obj, &DiscConnControlInstance, idlen, CONTROLINDEXSIZE)) == NULL)
                    return SNMP_GENERROR;
                if ((local->Data = DnpapMalloc(sizeof(DISCCONN_CONTROL))) == NULL)
                    return SNMP_GENERROR;
                data = (DISCCONN_CONTROL*) local->Data;
                memset(data, 0, sizeof(DISCCONN_CONTROL));
                if (DiscConnCInit(data) == TRUE)
                {
                    data->Status = SNMP_UNDERCREATION;
                    DnpapMessage(DMC_MESSAGE, DISC_CREATE, "discconn: collector %ld created", local->Index);
                    return SNMP_NOERROR;
                }
                DnpapFree(local->Data);
                MibRemove (obj, &DiscConnControlInstance, idlen, CONTROLINDEXSIZE);
                return SNMP_GENERROR;
            default:
                return SNMP_NOSUCHNAME;
            }
        }
        data = (DISCCONN_CONTROL*) local->Data;
        switch (data->Status)
        {
        case SNMP_UNDERCREATION:
            switch (obj->Syntax.LngInt)
            {
            case SNMP_VALID:
                if (DiscConnCStart(data) == TRUE)
                {
                    data->Status = SNMP_VALID;
                    DnpapMessage(DMC_MESSAGE, DISC_START, "discconn: collector %ld active", local->Index);
                    return SNMP_NOERROR;
                }
                return SNMP_BADVALUE;
            case SNMP_INVALID:
                if (DiscConnCStop(data) == TRUE)
                {
                    DnpapFree(local->Data);