コード例 #1
0
        public MibNode GenerateTree()
        {
            //Hardcoded roots of the tree
            var masterNode = new MibNode(1, "ISO", null);

            masterNode.AddChild(new MibNode(3, "org", masterNode));

            var org = masterNode.GetMibNodeStack().FirstOrDefault(node => node.NodeName == "org");

            org?.AddChild(new MibNode(6, "dod", org));

            var dod = masterNode.GetMibNodeStack().FirstOrDefault(node => node.NodeName == "dod");

            dod?.AddChild(new MibNode(1, "internet", dod));

            var internet = masterNode.GetMibNodeStack().FirstOrDefault(node => node.NodeName == "internet");

            internet?.AddChild(new MibNode(2, "mgmt", internet));


            var mibText = fileReader.GetFileEntireText(ParserConst.MIBPath);

            //Load imports
            var imports = importsLoader.ParseImports(mibText); //TODO load this files

            var objectIdentifierMatch = objectIdentifierRegex.Matches(mibText);

            foreach (Match match in objectIdentifierMatch)
            {
                var groups = match.Groups;

                var name        = groups["name"].ToString().Trim(' ');
                var parent      = groups["parent"].ToString().Split(' ')[1].Trim(' ');
                var valueString = groups["parent"].ToString().Split(' ')[2].Trim(' ');
                var value       = int.Parse(valueString);

                var parentNode = masterNode.GetMibNodeStack().FirstOrDefault(node => node.NodeName == parent);
                parentNode?.AddChild(new MibNode(value, name, parentNode));
            }

            var sequenceMatch = sequenceRegex.Matches(mibText);

            foreach (Match match in sequenceMatch)
            {
                var sequenceValues = getSequenceValuesRegex.Matches(match.Groups["values"].Value);
                foreach (Match sequenceValue in sequenceValues)
                {
                    var name  = sequenceValue.Groups["name"].Value;
                    var value = sequenceValue.Groups["value"].Value;

                    //TODO
                }
            }

            var objectTypeMatch = objectTypeRegex.Matches(mibText);

            foreach (Match match in objectTypeMatch)
            {
                var objectTypeText = match.Value;
                var name           = nameOfNode.Match(objectTypeText).Groups["name"].Value.Trim(' ');
                var typeOfNode     = this.typeOfNode.Match(objectTypeText).Groups["syntax"];
                var access         = typeOfAccess.Match(objectTypeText).Groups["access"];
                var status         = this.status.Match(objectTypeText).Groups["status"];
                var description    = this.description.Match(objectTypeText).Groups["description"];
                var parentName     = parentAndId.Match(objectTypeText).Groups["parent"];
                var id             = parentAndId.Match(objectTypeText).Groups["parentId"];

                if (IsObjectComplete(name, typeOfNode, access, status, parentName, id))
                {
                    var idParsed = int.Parse(id.ToString());

                    var parentNode = masterNode.GetMibNodeStack()
                                     .FirstOrDefault(node => node.NodeName == parentName.ToString());

                    AccessTypes accessType;
                    if (access.Value.Contains("read-write"))
                    {
                        accessType = AccessTypes.ReadWrite;
                    }
                    else if (access.Value.Contains("read-only"))
                    {
                        accessType = AccessTypes.ReadOnly;
                    }
                    else
                    {
                        accessType = AccessTypes.NoAccess;
                    }

                    if (typeOfNode.ToString().Contains("{"))
                    {
                        var valueOfType = complexTypeOfNode.Match(match.Value).Value;
                        var values      = getNumbers.Matches(valueOfType);
                        var min         = values[0].Value;
                        var max         = values[values.Count - 1].Value;
                        min = min.Substring(0, min.Length - 1);
                        max = max.Substring(0, max.Length - 1);

                        var limiter = new Limiter(int.Parse(min), int.Parse(max));

                        parentNode?.AddChild(new ObjectType(idParsed, name, parentNode, typeOfNode.Value, accessType,
                                                            status.Value, description.Value, limiter));
                    }
                    else if (typeOfNode.ToString().Contains(".."))
                    {
                        var numbers = splitDotNumbers.Match(typeOfNode.Value);
                        var min     = numbers.Groups["min"].Value;
                        var max     = numbers.Groups["max"].Value;
                        var limiter = new Limiter(int.Parse(min), int.Parse(max));

                        parentNode?.AddChild(new ObjectType(idParsed, name, parentNode, typeOfNode.Value, accessType,
                                                            status.Value, description.Value, limiter));
                    }
                    else
                    {
                        parentNode?.AddChild(new ObjectType(idParsed, name, parentNode, typeOfNode.Value, accessType,
                                                            status.Value, description.Value));
                    }
                }
            }
            return(masterNode);
        }
コード例 #2
0
        public byte[] ProcessMessage(byte[] incomingMessage)
        {
            var incoming = decoder.Decode(incomingMessage);
            var outgoing = new SNMPMessage();

            outgoing.SNMPMessageType = SNMPMessageTypes.GetResponse;
            outgoing.CommunityString = incoming.CommunityString;
            outgoing.RawObjectId     = incoming.RawObjectId;
            outgoing.ReqId           = incoming.ReqId;

            if (incoming.CommunityString != community)
            {
                return(null);
            }

            switch (incoming.SNMPMessageType)
            {
            case SNMPMessageTypes.GetRequest:
                if (incoming.ObjectId[incoming.ObjectId.Length - 1] == '0')
                {
                    var object_id = incoming.ObjectId.Substring(2);
                    var myNode    = (ObjectType)master.GetMibNodeStack()
                                    .FirstOrDefault(node => node.GetOID() == object_id.Substring(0, object_id.Length - 2));


                    if (myNode != null)
                    {
                        if (myNode.IsReadable())
                        {
                            switch (myNode.NodeType)
                            {
                            case NodeTypes.TypeInteger:
                                outgoing.IntValue = myNode.IntValue;
                                break;

                            case NodeTypes.TypeCounter:
                                outgoing.IntValue         = myNode.IntValue;
                                outgoing.AplicationSpecId = 0x41;
                                break;

                            case NodeTypes.TypeGauge:
                                outgoing.IntValue         = myNode.IntValue;
                                outgoing.AplicationSpecId = 0x42;
                                break;

                            case NodeTypes.TypeTimeTicks:
                                outgoing.IntValue         = myNode.IntValue;
                                outgoing.AplicationSpecId = 0x43;
                                break;

                            case NodeTypes.TypeDisplayString:
                            case NodeTypes.TypePhysAddress:
                                outgoing.OctetStringValue = myNode.OctetStringValue;
                                break;

                            default:
                                break;
                            }
                        }
                        else
                        {
                            outgoing.Error = 0x05;
                        }
                    }
                    else
                    {
                        outgoing.Error = 0x02;
                    }
                }
                break;

            case SNMPMessageTypes.SetRequest:
                if (incoming.ObjectId[incoming.ObjectId.Length - 1] == '0')
                {
                    var object_id = incoming.ObjectId.Substring(2);
                    var myNode    = (ObjectType)master.GetMibNodeStack()
                                    .FirstOrDefault(node => node.GetOID() == object_id.Substring(0, object_id.Length - 2));
                    if (myNode != null)
                    {
                        if (myNode.IsWritable())
                        {
                            if (incoming.OctetStringValue != null)
                            {
                                switch (myNode.NodeType)
                                {
                                case NodeTypes.TypeDisplayString:
                                case NodeTypes.TypePhysAddress:
                                    outgoing.OctetStringValue = incoming.OctetStringValue;
                                    if (myNode.SetValue(incoming.OctetStringValue))
                                    {
                                        ;
                                    }
                                    else
                                    {
                                        outgoing.Error = 0x05;
                                    }
                                    break;

                                default:
                                    outgoing.Error = 0x03;
                                    break;
                                }
                            }
                            else
                            {
                                switch (myNode.NodeType)
                                {
                                case NodeTypes.TypeInteger:
                                    outgoing.IntValue = incoming.IntValue;
                                    if (myNode.SetValue((int)incoming.IntValue))
                                    {
                                        ;
                                    }
                                    else
                                    {
                                        outgoing.Error = 0x05;
                                    }
                                    break;


                                case NodeTypes.TypeCounter:
                                    outgoing.IntValue         = incoming.IntValue;
                                    outgoing.AplicationSpecId = 0x41;
                                    if (myNode.SetValue((int)incoming.IntValue))
                                    {
                                        ;
                                    }
                                    else
                                    {
                                        outgoing.Error = 0x05;
                                    }
                                    break;

                                case NodeTypes.TypeGauge:
                                    outgoing.IntValue         = incoming.IntValue;
                                    outgoing.AplicationSpecId = 0x42;
                                    if (myNode.SetValue((int)incoming.IntValue))
                                    {
                                        ;
                                    }
                                    else
                                    {
                                        outgoing.Error = 0x05;
                                    }
                                    break;

                                case NodeTypes.TypeTimeTicks:
                                    outgoing.IntValue         = incoming.IntValue;
                                    outgoing.AplicationSpecId = 0x43;
                                    if (myNode.SetValue((int)incoming.IntValue))
                                    {
                                        ;
                                    }
                                    else
                                    {
                                        outgoing.Error = 0x05;
                                    }
                                    break;

                                default:
                                    outgoing.Error = 0x03;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            outgoing.Error = 0x04;
                        }
                    }
                    else
                    {
                        outgoing.Error = 0x02;
                    }
                }
                break;

            default:
                break;
            }

            var return_message = coder.Encode(outgoing);

            return(return_message);
        }