Пример #1
0
        private void SNMP_GET_BULK()
        {
            string adres = addressBox.Text;
            GetBulkRequestMessage message = new GetBulkRequestMessage(0,
                                                                      VersionCode.V2,
                                                                      new OctetString("public"),
                                                                      0,
                                                                      10,
                                                                      new List <Variable> {
                new Variable(new ObjectIdentifier(adres))
            });
            ISnmpMessage response = message.GetResponse(60000, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 161));

            if (response.Pdu().ErrorStatus.ToInt32() != 0)
            {
                throw new Exception();
            }

            var result = response.Pdu().Variables;

            foreach (var v in result)
            {
                consoleBox.Items.Add(v.ToString());
            }
        }
Пример #2
0
        protected override void ProcessRecord()
        {
            Dictionary <string, string> results = new Dictionary <string, string>();

            try
            {
                var request    = new GetBulkRequestMessage(0, VersionCode.V2, _community, 0, 5, _vList);
                var iPEndPoint = new IPEndPoint(IPAddress.Parse(Ip), 161);
                var reply      = request.GetResponse(_timeOut, iPEndPoint);
                var variables  = reply.Pdu().Variables;

                foreach (Variable variable in variables)
                {
                    var key  = GetOidDescription(variable.Id.ToString());
                    var data = ConvertVariableData(variable.Data);
                    if (data.Length > 0 && !results.ContainsKey(key))
                    {
                        results.Add(key, data);
                    }
                }

                WriteObject(results);
            }
            catch (Exception e)
            {
                WriteWarning($"Could not complete the request: {e.Message}");
            }
        }
Пример #3
0
        /// <summary>
        /// Get Bulk SNMP
        /// </summary>
        /// <param name="inputoid"></param>
        /// <returns></returns>
        public static List <Variable> BulkSNMP(string inputoid, string address, int port, string community)
        {
            List <Variable> retlist = new List <Variable>();

            try
            {
                GetBulkRequestMessage message = new GetBulkRequestMessage(0,
                                                                          VersionCode.V2,
                                                                          new OctetString(community),
                                                                          0,
                                                                          10,
                                                                          new List <Variable> {
                    new Variable(new ObjectIdentifier(inputoid))
                });
                ISnmpMessage response = message.GetResponse(60000, new IPEndPoint(IPAddress.Parse(address), port));
                if (response.Pdu().ErrorStatus.ToInt32() != 0)
                {
                    throw ErrorException.Create(
                              "error in response",
                              IPAddress.Parse(address),
                              response);
                }
                retlist = response.Pdu().Variables.ToList();
            }
            catch (Exception)
            {
            }
            return(retlist);
        }
Пример #4
0
        public IList <Variable> GetBulk(int maxRepetitions)
        {
            GetBulkRequestMessage message = new GetBulkRequestMessage(0, SnmpVersion, Community, 0, maxRepetitions, Oids);

            Oids = new List <Variable>();
            ISnmpMessage result = message.GetResponse(Timeout, Ip);

            return(result.Variables());
        }
Пример #5
0
        public async Task <IList <Variable> > GetBulk(int maxRepetitions)
        {
            ISnmpMessage          result  = null;
            GetBulkRequestMessage message = new GetBulkRequestMessage(0, SnmpVersion, Community, 0, maxRepetitions, Oids);

            Oids   = new List <Variable>();
            result = await message.GetResponseAsync(Ip);

            return(result.Variables());
        }
Пример #6
0
        private List <Variable> GetBulk(List <Variable> vList)
        {
            GetBulkRequestMessage message = new GetBulkRequestMessage(0,
                                                                      version,
                                                                      new OctetString(community),
                                                                      nonRepeaters,
                                                                      maxRepetitions, vList);
            List <Variable> RsltList = new List <Variable>();;

            try
            {
                response = message.GetResponse(5000, receiver);
            }

            catch (Exception e)
            {
                strError = "Error Retrieving Property";
                return(null);
            }
            if (response.Pdu().ErrorStatus.ToInt32() != 0)
            {
                strError = "Error Retrieving Property";
                return(null);
            }
            else
            {
                foreach (Variable variable in response.Pdu().Variables)
                {
                    RsltList.Add(variable);
                }
                //  RsltList = List<Variable>(response.Pdu().Variables);
            }



            return(RsltList);
        }
        public void SnmpGetBulk(string community, string ipAddress, string oidKey)
        {
            GetBulkRequestMessage message = new GetBulkRequestMessage(0,
                                                                      VersionCode.V2,
                                                                      new OctetString(community),
                                                                      0,
                                                                      10,
                                                                      new List <Variable> {
                new Variable(new ObjectIdentifier(oidKey))
            });
            ISnmpMessage response = message.GetResponse(6000, new IPEndPoint(IPAddress.Parse(ipAddress), 161));

            if (response.Pdu().ErrorStatus.ToInt32() != 0)
            {
                throw ErrorException.Create(
                          "Error in response!",
                          IPAddress.Parse(ipAddress),
                          response);
            }

            var result = response.Pdu().Variables;

            variableList = result.ToList();
        }
        //----------------------------------------------------------------------------
        //SNMPGETBULK
        public void SnmpGetBulk(string oidKey)
        {
            GetBulkRequestMessage message = new GetBulkRequestMessage(0,
                                                                      VersionCode.V2,
                                                                      community,
                                                                      0,
                                                                      10,
                                                                      new List <Variable> {
                new Variable(new ObjectIdentifier(oidKey))
            });
            ISnmpMessage response = message.GetResponse(6000, server);

            if (response.Pdu().ErrorStatus.ToInt32() != 0)
            {
                throw ErrorException.Create(
                          "Error in response",
                          server.Address,
                          response);
            }

            var result = response.Pdu().Variables;

            variableList = result.ToList();
        }
Пример #9
0
        public static IList <Variable> GetBulk(string IpAddress, string readPermissionString, string Identifier, int readPort)
        {
            GetBulkRequestMessage message = new GetBulkRequestMessage(0,
                                                                      VersionCode.V2,
                                                                      new OctetString(readPermissionString),
                                                                      0,
                                                                      10,
                                                                      new List <Variable> {
                new Variable(new ObjectIdentifier(Identifier))
            });
            ISnmpMessage response = message.GetResponse(60000, new IPEndPoint(IPAddress.Parse(IpAddress), readPort));

            if (response.Pdu().ErrorStatus.ToInt32() != 0)
            {
                throw ErrorException.Create(
                          "error in response",
                          IPAddress.Parse(IpAddress),
                          response);
            }

            var result = response.Pdu().Variables;

            return(result);
        }
Пример #10
0
        public static void Main(string[] args)
        {
            string      community      = "public";
            bool        showHelp       = false;
            bool        showVersion    = false;
            VersionCode version        = VersionCode.V2; // GET BULK is available in SNMP v2 and above.
            int         timeout        = 1000;
            int         retry          = 0;
            Levels      level          = Levels.Reportable;
            string      user           = string.Empty;
            string      authentication = string.Empty;
            string      authPhrase     = string.Empty;
            string      privacy        = string.Empty;
            string      privPhrase     = string.Empty;
            int         maxRepetitions = 10;
            int         nonRepeaters   = 0;
            bool        dump           = false;

            OptionSet p = new OptionSet()
                          .Add("c:", "Community name, (default is public)", delegate(string v) { if (v != null)
                                                                                                 {
                                                                                                     community = v;
                                                                                                 }
                               })
                          .Add("l:", "Security level, (default is noAuthNoPriv)", delegate(string v)
            {
                if (v.ToUpperInvariant() == "NOAUTHNOPRIV")
                {
                    level = Levels.Reportable;
                }
                else if (v.ToUpperInvariant() == "AUTHNOPRIV")
                {
                    level = Levels.Authentication | Levels.Reportable;
                }
                else if (v.ToUpperInvariant() == "AUTHPRIV")
                {
                    level = Levels.Authentication | Levels.Privacy | Levels.Reportable;
                }
                else
                {
                    throw new ArgumentException("no such security mode: " + v);
                }
            })
                          .Add("Cn:", "Non-repeaters (default is 0)", delegate(string v) { nonRepeaters = int.Parse(v); })
                          .Add("Cr:", "Max-repetitions (default is 10)", delegate(string v) { maxRepetitions = int.Parse(v); })
                          .Add("a:", "Authentication method (MD5 or SHA)", delegate(string v) { authentication = v; })
                          .Add("A:", "Authentication passphrase", delegate(string v) { authPhrase = v; })
                          .Add("x:", "Privacy method", delegate(string v) { privacy = v; })
                          .Add("X:", "Privacy passphrase", delegate(string v) { privPhrase = v; })
                          .Add("u:", "Security name", delegate(string v) { user = v; })
                          .Add("h|?|help", "Print this help information.", delegate(string v) { showHelp = v != null; })
                          .Add("V", "Display version number of this application.", delegate(string v) { showVersion = v != null; })
                          .Add("d", "Display message dump", delegate(string v) { dump = true; })
                          .Add("t:", "Timeout value (unit is second).", delegate(string v) { timeout = int.Parse(v) * 1000; })
                          .Add("r:", "Retry count (default is 0)", delegate(string v) { retry = int.Parse(v); })
                          .Add("v:", "SNMP version (2 and 3 are currently supported)", delegate(string v)
            {
                switch (int.Parse(v))
                {
                case 2:
                    version = VersionCode.V2;
                    break;

                case 3:
                    version = VersionCode.V3;
                    break;

                default:
                    throw new ArgumentException("no such version: " + v);
                }
            });

            if (args.Length == 0)
            {
                ShowHelp(p);
                return;
            }

            List <string> extra;

            try
            {
                extra = p.Parse(args);
            }
            catch (OptionException ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }

            if (showHelp)
            {
                ShowHelp(p);
                return;
            }

            if (extra.Count < 2)
            {
                Console.WriteLine("invalid variable number: " + extra.Count);
                return;
            }

            if (showVersion)
            {
                Console.WriteLine(System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
                return;
            }

            IPAddress ip;
            bool      parsed = IPAddress.TryParse(extra[0], out ip);

            if (!parsed)
            {
                foreach (IPAddress address in
                         Dns.GetHostAddresses(extra[0]).Where(address => address.AddressFamily == AddressFamily.InterNetwork))
                {
                    ip = address;
                    break;
                }

                if (ip == null)
                {
                    Console.WriteLine("invalid host or wrong IP address found: " + extra[0]);
                    return;
                }
            }

            try
            {
                List <Variable> vList = new List <Variable>();
                for (int i = 1; i < extra.Count; i++)
                {
                    Variable test = new Variable(new ObjectIdentifier(extra[i]));
                    vList.Add(test);
                }

                IPEndPoint receiver = new IPEndPoint(ip, 161);
                if (version != VersionCode.V3)
                {
                    GetBulkRequestMessage message = new GetBulkRequestMessage(0,
                                                                              version,
                                                                              new OctetString(community),
                                                                              nonRepeaters,
                                                                              maxRepetitions,
                                                                              vList);
                    ISnmpMessage response = message.GetResponse(timeout, receiver);
                    if (response.Pdu().ErrorStatus.ToInt32() != 0) // != ErrorCode.NoError
                    {
                        throw ErrorException.Create(
                                  "error in response",
                                  receiver.Address,
                                  response);
                    }

                    foreach (Variable variable in response.Pdu().Variables)
                    {
                        Console.WriteLine(variable);
                    }

                    return;
                }

                if (string.IsNullOrEmpty(user))
                {
                    Console.WriteLine("User name need to be specified for v3.");
                    return;
                }

                IAuthenticationProvider auth = (level & Levels.Authentication) == Levels.Authentication
                                                   ? GetAuthenticationProviderByName(authentication, authPhrase)
                                                   : DefaultAuthenticationProvider.Instance;

                IPrivacyProvider priv;
                if ((level & Levels.Privacy) == Levels.Privacy)
                {
                    priv = new DESPrivacyProvider(new OctetString(privPhrase), auth);
                }
                else
                {
                    priv = new DefaultPrivacyProvider(auth);
                }

                Discovery     discovery = Messenger.GetNextDiscovery(SnmpType.GetBulkRequestPdu);
                ReportMessage report    = discovery.GetResponse(timeout, receiver);

                GetBulkRequestMessage request = new GetBulkRequestMessage(VersionCode.V3, Messenger.NextMessageId, Messenger.NextRequestId, new OctetString(user), nonRepeaters, maxRepetitions, vList, priv, Messenger.MaxMessageSize, report);
                ISnmpMessage          reply   = request.GetResponse(timeout, receiver);
                if (dump)
                {
                    Console.WriteLine("Request message bytes:");
                    Console.WriteLine(ByteTool.Convert(request.ToBytes()));
                    Console.WriteLine("Response message bytes:");
                    Console.WriteLine(ByteTool.Convert(reply.ToBytes()));
                }

                if (reply is ReportMessage)
                {
                    if (reply.Pdu().Variables.Count == 0)
                    {
                        Console.WriteLine("wrong report message received");
                        return;
                    }

                    var id = reply.Pdu().Variables[0].Id;
                    if (id != Messenger.NotInTimeWindow)
                    {
                        var error = id.GetErrorMessage();
                        Console.WriteLine(error);
                        return;
                    }

                    // according to RFC 3414, send a second request to sync time.
                    request = new GetBulkRequestMessage(VersionCode.V3, Messenger.NextMessageId, Messenger.NextRequestId, new OctetString(user), nonRepeaters, maxRepetitions, vList, priv, Messenger.MaxMessageSize, reply);
                    reply   = request.GetResponse(timeout, receiver);
                }
                else if (reply.Pdu().ErrorStatus.ToInt32() != 0) // != ErrorCode.NoError
                {
                    throw ErrorException.Create(
                              "error in response",
                              receiver.Address,
                              reply);
                }

                foreach (Variable v in reply.Pdu().Variables)
                {
                    Console.WriteLine(v);
                }
            }
            catch (SnmpException ex)
            {
                Console.WriteLine(ex);
            }
            catch (SocketException ex)
            {
                Console.WriteLine(ex);
            }
        }