dfilterm.c

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

}

WORD DnpapFilterPktStatus(SNMP_OBJECT *Obj, WORD IdLen)
{
    MIB_LOCAL   *local = NULL;
    DNPAP_FILTER      *data;

    if ((local = MibRmon(Obj, filter, IdLen, INDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (Obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext (Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DNPAP_FILTER*) local->Data;
        Obj->Syntax.LngInt = data->PktStatus;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
        data = (DNPAP_FILTER*) local->Data;
        if (data->Status != SNMP_UNDERCREATION)
            return SNMP_READONLY;
        /* This is not supported: can not be set */
        return SNMP_BADVALUE;
    }
    return SNMP_GENERROR;
}

WORD DnpapFilterPktStatusMask(SNMP_OBJECT *Obj, WORD IdLen)
{
    MIB_LOCAL   *local = NULL;
    DNPAP_FILTER      *data;

    if ((local = MibRmon(Obj, filter, IdLen, INDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (Obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext (Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DNPAP_FILTER*) local->Data;
        Obj->Syntax.LngInt = data->PktStatusMask;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
        data = (DNPAP_FILTER*) local->Data;
        if (data->Status != SNMP_UNDERCREATION)
            return SNMP_READONLY;
        /* This is not supported: can not be set */
        return SNMP_BADVALUE;
    }
    return SNMP_GENERROR;
}

WORD DnpapFilterPktStatusNotMask(SNMP_OBJECT *Obj, WORD IdLen)
{
    MIB_LOCAL   *local = NULL;
    DNPAP_FILTER      *data;

    if ((local = MibRmon(Obj, filter, IdLen, INDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (Obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext (Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DNPAP_FILTER*) local->Data;
        Obj->Syntax.LngInt = data->PktStatusNotMask;
        return SNMP_NOERROR;
    case SNMP_PDU_SET:
        data = (DNPAP_FILTER*) local->Data;
        if (data->Status != SNMP_UNDERCREATION)
            return SNMP_READONLY;
        /* This is not supported: can not be set */
        return SNMP_BADVALUE;
    }
    return SNMP_GENERROR;
}


WORD DnpapFilterOwner(SNMP_OBJECT *Obj, WORD IdLen)
{
    MIB_LOCAL   *local = NULL;
    DNPAP_FILTER      *data;

    if ((local = MibRmon(Obj, filter, IdLen, INDEXSIZE)) == NULL)
        return SNMP_NOSUCHNAME;

    switch (Obj->Request)
    {
    case SNMP_PDU_NEXT:
        if (RmonNext (Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
            return SNMP_NOSUCHNAME;
    case SNMP_PDU_GET:
        data = (DNPAP_FILTER*) local->Data;
		if (BeholderStrictRMON && !BooleanCheck(data->ObjectSet, FILTER_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 = (DNPAP_FILTER*) 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, FILTER_BOOLEAN_OWNER);
        return SNMP_NOERROR;
    }
    return SNMP_GENERROR;
}

WORD DnpapFilterStatus(SNMP_OBJECT *Obj, WORD IdLen)
{
    MIB_LOCAL   *local = NULL;
    DNPAP_FILTER      *data;

    local = MibRmon(Obj, filter, IdLen, INDEXSIZE);

    switch (Obj->Request)
    {
    case SNMP_PDU_GET:
        if (local == NULL)
        {
            Obj->Syntax.LngInt = SNMP_INVALID;
            return SNMP_NOSUCHNAME;
        }
        data = (DNPAP_FILTER*) local->Data;
        Obj->Syntax.LngInt = data->Status;
        return SNMP_NOERROR;
    case SNMP_PDU_NEXT:
        if (RmonNext (Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
        {
            Obj->Syntax.LngInt = SNMP_INVALID;
            return SNMP_NOSUCHNAME;
        }
        data = (DNPAP_FILTER*) 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, &filter, IdLen, INDEXSIZE)) == NULL)
                        return SNMP_GENERROR;
                    if ((local->Data = DnpapMalloc(sizeof(DNPAP_FILTER))) == NULL)
                        return SNMP_GENERROR;
                    data = (DNPAP_FILTER*) local->Data;
                    memset(data, 0, sizeof(DNPAP_FILTER));
                    if (DnpapFilterCInit(data) == TRUE)
                    {
                        data->Status = SNMP_UNDERCREATION;
                        DnpapMessage(DMC_MESSAGE, DFILTER_CREATE, "filter: collector %ld created", local->Index);
                        return SNMP_NOERROR;
                    }
                    DnpapFree(local->Data);
                    MibRemove (Obj, &filter, IdLen, INDEXSIZE);
                    return SNMP_GENERROR;
                default:
                    return SNMP_NOSUCHNAME;
            }
        }
        data = (DNPAP_FILTER*) local->Data;
        switch (data->Status)
        {
        case SNMP_UNDERCREATION:
            switch (Obj->Syntax.LngInt)
            {
            case SNMP_VALID:
                if (DnpapFilterCStart(data) == TRUE)
                {
                    data->Status = SNMP_VALID;
                    DnpapMessage(DMC_MESSAGE, DFILTER_ACTIVE, "filter: collector %ld active", local->Index);
                    return SNMP_NOERROR;
                }
                return SNMP_BADVALUE;
            case SNMP_INVALID:
                if (DnpapFilterCStop(data) == TRUE)
                {
                    DnpapFree(local->Data);
                    DnpapMessage(DMC_MESSAGE, DFILTER_DESTROY, "filter: collector %ld destroyed", local->Index);
                    if (MibRemove (Obj, &filter, IdLen, INDEXSIZE) == TRUE)
                        return SNMP_NOERROR;
                }
                return SNMP_GENERROR;
            default:
                return SNMP_BADVALUE;
            }
        case SNMP_VALID:
            switch (Obj->Syntax.LngInt)
            {
            case SNMP_INVALID:
                if (DnpapFilterCStop(data) == TRUE)
                {
                    DnpapFree(local->Data);
                    DnpapMessage(DMC_MESSAGE, DFILTER_DESTROY, "filter: collector %ld destroyed", local->Index);
                    if (MibRemove (Obj, &filter, IdLen, INDEXSIZE) == TRUE)
                        return SNMP_NOERROR;
                }
                return SNMP_GENERROR;
            case SNMP_VALID:
                return SNMP_NOERROR;
            default:
                return SNMP_BADVALUE;
            }
        }
    }
    return SNMP_GENERROR;
}


BOOLEAN DnpapFilterPkt(LONG channelIndex, PROT_PKT *pkt)
{
MIB_LOCAL *local;
DNPAP_FILTER *data;
PROT_OBJ len =   {0, {1,5}};
PROT_OBJ packet= {0, {1,7}};
BYTE scratch;
WORD bi, fb, lb;
BOOLEAN rule2fail, rule3fail, filterfound;

    if (ProtGetField(pkt, &len) == FALSE ||
        ProtGetField(pkt, &packet) == FALSE) 
    {
        DnpapMessage(DMC_ERROR, DFILTER_BADPACKET,"filter: bad packet");
        return FALSE;
    }

    /*  All results of filters that apply are OR'ed. Actually lazy evaluation  */
    /*  is implemented: the first filter that matches returns TRUE.            */
    /*  In the heuristics below, a 'continue' is equivalent to a failing match.  */
    filterfound = FALSE;
    for (local = filter; local != NULL; local = local->Next)
    {
        data = (DNPAP_FILTER*) local->Data;
        if (data->Status == SNMP_VALID && data->Channel == channelIndex)
        {
            filterfound = TRUE;
            if (data->PktDataLen + data->PktDataOffset > len.Syntax.LngInt)
                continue;       /*  rule 1 of packet matching  */
            if (data->PktDataLen == 0)
                return TRUE;	/*  no data, match everything */
            fb = (WORD)data->PktDataOffset;
            lb = (WORD)data->PktDataOffset+data->PktDataLen;
            rule2fail = FALSE;
            if (data->PktDataNotMaskAllZero == TRUE)
                rule3fail = FALSE;
            else
                rule3fail = TRUE;
            for (bi = fb; bi < lb; bi++)
            {
                scratch = (((BYTE*)packet.Syntax.Ptr)[bi] ^ data->PktData[bi-fb]) & data->PktDataMask[bi-fb];
                if ((scratch & ~data->PktDataNotMask[bi-fb]) != 0)
                {
                    rule2fail = TRUE;
                    break;
                }
                if (rule3fail == TRUE && (scratch & data->PktDataNotMask[bi-fb]) != 0)
                    rule3fail = FALSE;
            }
            if (rule2fail == FALSE && rule3fail == FALSE)
            {
                return TRUE;
            }
            else
                continue;
        }
    }

    return FALSE;
}