/// <summary> /// SNMP GET-NEXT request /// </summary> /// <example>SNMP GET-NEXT request: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// Dictionary<Oid, AsnType> result = snmp.GetNext(SnmpVersion.Ver1, new string[] { "1.3.6.1.2.1.1" }); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// foreach (KeyValuePair<Oid, AsnType> entry in result) /// { /// Console.WriteLine("{0} = {1}: {2}", entry.Key.ToString(), SnmpConstants.GetTypeName(entry.Value.Type), /// entry.Value.ToString()); /// } /// } /// </code> /// Will return: /// <code> /// 1.3.6.1.2.1.1.1.0 = OctetString: "Dual core Intel notebook" /// </code> /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="oidList">List of request OIDs in string dotted decimal format.</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary <Oid, AsnType> GetNext(SnmpVersion version, string[] oidList) { if (!Valid) { if (!_suppressExceptions) { throw new SnmpException("SimpleSnmp class is not valid."); } return(null); } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { if (!_suppressExceptions) { throw new SnmpInvalidVersionException("SimpleSnmp support SNMP version 1 and 2 only."); } return(null); } Pdu pdu = new Pdu(PduType.GetNext); foreach (string s in oidList) { pdu.VbList.Add(s); } return(GetNext(version, pdu)); }
/// <summary> /// Funkcja realizująca polecenie GetNext agenta SNMP. /// SnmpVersion: SnmpVersion.Ver1 lub SnmpVersion.Ver2 lub SnmpVersion.Ver3. Zalecana Ver2. /// oidList: Lista identyfikatorów OID, których obiekty ma znalezc funkcja. /// </summary> /// <param name="version"></param> /// <param name="oid"></param> /// <param name="agent"></param> /// <returns></returns> public SnmpPacket GetNextRequest(SnmpVersion version, string[] oidList, IPAddress agent) { // Pdu class used for all requests Pdu pdu = new Pdu(PduType.GetNext); foreach (var oid in oidList) { pdu.VbList.Add(oid); } // SNMP community name OctetString community = new OctetString(snmp.Community); // Define agent parameters class AgentParameters param = new AgentParameters(community); // Set SNMP version to 1 (or 2) param.Version = version; // Make SNMP request SnmpPacket result = target.Request(pdu, param); return(result); }
/// <summary> /// SNMP SET request /// </summary> /// <example>Set operation in SNMP version 1: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// // Create a request Pdu /// List<Vb> vbList = new List<Vb>(); /// Oid setOid = new Oid("1.3.6.1.2.1.1.1.0"); // sysDescr.0 /// OctetString setValue = new OctetString("My personal toy"); /// vbList.Add(new Vb(setOid, setValue)); /// Dictionary<Oid, AsnType> result = snmp.Set(SnmpVersion.Ver1, list.ToArray()); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// Console.WriteLine("Success!"); /// } /// </code> /// /// To use SNMP version 2, change snmp.Set() method call first parameter to SnmpVersion.Ver2. /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="vbs">Vb array containing Oid/AsnValue pairs for the SET operation</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary <Oid, AsnType> Set(SnmpVersion version, Vb[] vbs) { if (!Valid) { if (!_suppressExceptions) { throw new SnmpException("SimpleSnmp class is not valid."); } return(null); } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { if (!_suppressExceptions) { throw new SnmpInvalidVersionException("SimpleSnmp support SNMP version 1 and 2 only."); } return(null); } Pdu pdu = new Pdu(PduType.Set); foreach (Vb vb in vbs) { pdu.VbList.Add(vb); } return(Set(version, pdu)); }
private User User; // Provides SNMPv3 User details #endregion Properties #region Interface Methods public bool OpenSession(IPAddress deviceIp, short port, string community, int version, string username, string authPass, string privPass) { try { DeviceEndPoint = new IPEndPoint(deviceIp, port); Community = community; Version = GetVersionByInt(version); if (Version == SnmpVersion.Three) { // TODO: Remote Operator Panel shall encrypt in Aes256. User = new User(username, authPass, AuthenticationProtocol.Sha, privPass, PrivacyProtocol.Aes128); } _manager = new Manager(); using (var mibFile = new FileStream(Settings.Default.MIBPath, FileMode.Open, FileAccess.Read)) { _manager.Mib.Parse(mibFile); _manager.Mib.GenerateNodes(); } _manager.Security.TrapUsers.Add(User); _manager.Start(new NotificationReceived(TrapReceived), new Dart.Snmp.IPEndPoint("", 162), true, null); _isOpen = true; } catch (Exception) { return(false); } return(true); }
/// <summary> /// Reset the class. Initialize all member values to class defaults. /// </summary> public void Reset() { _address = new IpAddress(System.Net.IPAddress.Loopback); _port = 161; _version = SnmpVersion.Ver3; _timeout = 2000; _retry = 1; _engineId = new OctetString(); _engineBoots = new Integer32(); _engineTime = new Integer32(); _engineTimeStamp = DateTime.MinValue; _privacyProtocol = PrivacyProtocols.None; _authenticationProtocol = AuthenticationDigests.None; _privacySecret = new MutableByte(); _authenticationSecret = new MutableByte(); _contextEngineId = new OctetString(); _contextName = new OctetString(); _securityName = new OctetString(); // max message size is initialized to 64KB by default. It will be // to the smaller of the two values after discovery process _maxMessageSize = new Integer32(64 * 1024); _reportable = true; }
private static int GetMaxRepetitions(PduType type, SnmpVersion version, int vbCount, int rowCount, int maxRows, int rowsPerQuery) { if (type != PduType.GetBulk) { return(0); } // This is a simple heuristic algorithm that allows to limit // the size of a GetBulk response (to fit in a MTU packet). if (rowsPerQuery <= 0) { int header = version == SnmpVersion.SNMPv3 ? MAX_HEADER_V3_SIZE_ : MAX_HEADER_V1_SIZE_; rowsPerQuery = ((MAX_DATAGRAM_SIZE_ - header) / vbCount) / AVG_VARBIND_SIZE_; } int toRead = maxRows - rowCount; if (toRead < rowsPerQuery && toRead > 0) { rowsPerQuery = toRead; } return(rowsPerQuery); }
/// <summary> /// Construct from all the parameters. /// </summary> /// <param name="port">The port number to use for the queries.</param> /// <param name="protocolVersion">The SNMP protocol version to use for the queries.</param> /// <param name="community">The community string to use for the queries.</param> /// <param name="timeout">The query timeout.</param> /// <param name="retries">The SNMP peer maximum retires setting. Value of 0 will result in a single request with no retries.</param> /// <param name="ver2cMaximumValuesPerRequest">A value telling the SNMP Agent how many GETNEXT like variables to retrieve</param> /// <param name="ver2cMaximumRequests">A value telling the SNMP Agent how many VBs to include in a single request.<br/> /// Only valid on GETBULK requests.</param> /// <param name="enableCaching">Value indicating whether to use caching of non-volatile data.</param> /// <param name="loginUser">The user name for logins (if needed).</param> /// <param name="loginPassword">The password for logins (if needed).</param> /// <param name="allowedApis">The allowed APIs. By default, only SNMP is allowed.</param> /// <param name="querierClassHint">If not null or empty, a full qualified class name of the handler class to use (if possible).</param> public QuerierOptions( int port, SnmpVersion protocolVersion, OctetString community, TimeSpan timeout, int retries, int ver2cMaximumValuesPerRequest, int ver2cMaximumRequests, bool enableCaching, string loginUser, string loginPassword, QueryApis allowedApis, string querierClassHint = null) { this.Port = port; this.ProtocolVersion = protocolVersion; this.Community = community; this.Timeout = timeout; this.Retries = retries; this.Ver2cMaximumRequests = ver2cMaximumRequests; this.Ver2cMaximumValuesPerRequest = ver2cMaximumValuesPerRequest; this.EnableCaching = enableCaching; this.LoginUser = loginUser; this.LoginPassword = loginPassword; this.AllowedApis = allowedApis; this.QuerierClassHint = querierClassHint; }
/// <summary> /// Constructor /// </summary> public CTarget() { _address = new IpAddress(System.Net.IPAddress.Loopback); _port = 161; _version = SnmpVersion.Ver2; _timeout = 2000; _retry = 1; _community = "public"; }
public Entity(string ip, SnmpVersion version, string communityName, int port, PduType pduType, string oid) { this.IP = ip; this.Version = version; this.CommunityName = communityName; this.Port = port; this.PduType = pduType; this.OID = new Oid(oid); }
/// <summary> /// Converts the Asn.1 encoded byte array to SNMP Datagram. /// </summary> /// <param name="bytes">The asn.1 encoded bytes.</param> /// <returns> /// SnmpPacket /// </returns> /// <exception cref="System.ArgumentNullException">bytes</exception> /// <exception cref="System.IO.InvalidDataException">Snmp Version V3 not supported</exception> /// <exception cref="System.NotImplementedException">SNMP v1 traps are not yet implemented</exception> public static SnmpDatagram ToSnmpDatagram(this byte[] bytes) { if (bytes == null || bytes.Length == 0) { throw new ArgumentNullException("bytes"); } int offset = 0; int length; offset = bytes.NextValueLength(offset, -1, -1, -1, out length); offset = bytes.NextValueLength(offset, -1, -1, (int)Asn1Tag.Integer, out length); SnmpVersion snmpVersion = (SnmpVersion)bytes.ReadInteger(offset, length); offset += length; if (snmpVersion == SnmpVersion.V3) { throw new InvalidDataException("Snmp Version V3 not supported"); } offset = bytes.NextValueLength(offset, -1, -1, (int)Asn1Tag.OctetString, out length); string community = bytes.ReadOctetString(offset, length); offset += length; PduType pduType = (PduType)(bytes[offset++] & 0x1F); if (pduType == PduType.Trap) { throw new NotImplementedException("SNMP v1 traps are not yet implemented"); } offset = bytes.ReadLength(offset, out length); offset = bytes.NextValueLength(offset, -1, -1, (int)Asn1Tag.Integer, out length); int requestId = bytes.ReadInteger(offset, length); offset += length; offset = bytes.NextValueLength(offset, -1, -1, (int)Asn1Tag.Integer, out length); SnmpErrorStatus errorStatus = (SnmpErrorStatus)bytes.ReadInteger(offset, length); offset += length; offset = bytes.NextValueLength(offset, -1, -1, (int)Asn1Tag.Integer, out length); int errorIndex = bytes.ReadInteger(offset, length); offset += length; offset = bytes.NextValueLength(offset, (int)Asn1Class.Universal, (int)ConstructType.Constructed, (int)Asn1Tag.Sequence, out length); VarBind[] varBinds = bytes.ReadVarBinds(offset, length); return(new SnmpDatagram(new SnmpHeader(snmpVersion, community), new SnmpPDU(pduType, varBinds, requestId, errorStatus, errorIndex))); }
private void Init(string adresseIP, int retry, int timeout, SnmpVersion version, string communaute, int portLocal, int portDistant) { m_adresseIP = adresseIP; m_retry = retry; m_timeout = timeout; m_version = version; m_communaute = communaute; m_portLocal = portLocal; m_portDistant = portDistant; }
public SnmpHelper(string commnuity, string destIpAddr, long destPort, long trapPort , SnmpVersion version, long timeOut) { this.m_Community = commnuity; this.m_DestIPAddr = destIpAddr; this.m_DestPort = destPort; this.m_TrapPort = trapPort; this.m_Version = version; this.m_TimeOut = timeOut; ConnectToAgent(m_Community, m_DestIPAddr); }
public IEnumerable<SnmpResult> GetBulk(SnmpVersion version, int maxBulkRepetiotions, string octetString, Oid oid, IPAddress ipAddress = null, string hostname = null, string userLoginV3 = null, string passwordV3 = null) { if (ipAddress != null) { return GetBulkOperation(version, ipAddress, maxBulkRepetiotions, octetString, oid); } else if (!string.IsNullOrEmpty(hostname)) { return GetBulkOperation(version, GetIpAddressFromHostName(hostname), maxBulkRepetiotions, octetString, oid); } return null; }
public IEnumerable<SnmpResult> Walk(SnmpVersion version, string octetString, Oid oid, WalkingMode walkMode, IPAddress ipAddress = null, string hostname = null, string userLoginV3 = null, string passwordV3 = null) { if (ipAddress != null) { return WalkOperation(version, ipAddress, octetString, oid, walkMode); } else if (!string.IsNullOrEmpty(hostname)) { return WalkOperation(version, GetIpAddressFromHostName(hostname), octetString, oid, walkMode); } return null; }
/// <summary>SNMP WALK operation</summary> /// <remarks> /// When using SNMP version 1, walk is performed using GET-NEXT calls. When using SNMP version 2, /// walk is performed using GET-BULK calls. /// </remarks> /// <example>Example SNMP walk operation using SNMP version 1: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// Dictionary<Oid, AsnType> result = snmp.Walk(SnmpVersion.Ver1, "1.3.6.1.2.1.1"); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// foreach (KeyValuePair<Oid, AsnType> entry in result) /// { /// Console.WriteLine("{0} = {1}: {2}", entry.Key.ToString(), SnmpConstants.GetTypeName(entry.Value.Type), /// entry.Value.ToString()); /// } /// </code> /// Will return: /// <code> /// 1.3.6.1.2.1.1.1.0 = OctetString: "Dual core Intel notebook" /// 1.3.6.1.2.1.1.2.0 = ObjectId: 1.3.6.1.9.233233.1.1 /// 1.3.6.1.2.1.1.3.0 = TimeTicks: 0d 0h 0m 1s 420ms /// 1.3.6.1.2.1.1.4.0 = OctetString: "*****@*****.**" /// 1.3.6.1.2.1.1.5.0 = OctetString: "milans-nbook" /// 1.3.6.1.2.1.1.6.0 = OctetString: "Developer home" /// 1.3.6.1.2.1.1.8.0 = TimeTicks: 0d 0h 0m 0s 10ms /// </code> /// /// To use SNMP version 2, change snmp.Set() method call first parameter to SnmpVersion.Ver2. /// </example> /// <param name="version">SNMP protocol version. Acceptable values are SnmpVersion.Ver1 and /// SnmpVersion.Ver2</param> /// <param name="rootOid">OID to start WALK operation from. Only child OIDs of the rootOid will be /// retrieved and returned</param> /// <returns>Oid => AsnType value mappings on success, empty dictionary if no data was found or /// null on error</returns> public Dictionary <Oid, AsnType> Walk(SnmpVersion version, string rootOid) { if (rootOid.Length < 2) { return(null); } Oid root = new Oid(rootOid); if (root.Length <= 0) { return(null); // unable to parse root oid } Oid lastOid = (Oid)root.Clone(); Dictionary <Oid, AsnType> result = new Dictionary <Oid, AsnType>(); while (lastOid != null && root.IsRootOf(lastOid)) { Dictionary <Oid, AsnType> val = null; if (version == SnmpVersion.Ver1) { val = GetNext(version, new string[] { lastOid.ToString() }); } else { val = GetBulk(new string[] { lastOid.ToString() }); } // check that we have a result if (val == null) { // error of some sort happened. abort... return(null); } foreach (KeyValuePair <Oid, AsnType> entry in val) { if (root.IsRootOf(entry.Key)) { result.Add(entry.Key, entry.Value); lastOid = (Oid)entry.Key.Clone(); } else { // it's faster to check if variable is null then checking IsRootOf lastOid = null; break; } } } return(result); }
private void btnExecute_Click(object sender, EventArgs e) { if (txtOIDValue.Text.Trim().Length <= 0) { toast.ShowAlert("Xin hãy nhập OID:"); } else { Pdu pdu = new Pdu(); Dictionary <Oid, AsnType> dicOID = null; SimpleSnmp snmp = null; loadSNMPParameters(out snmp); SnmpVersion version = SnmpVersion.Ver2; if (cbbSNMPVersion.SelectedItem.Equals("1")) { version = SnmpVersion.Ver1; } VbCollection vbList = new VbCollection(); vbList.Add(txtOIDValue.Text); pdu.SetVbList(vbList); switch (cbbCommand.SelectedItem) { case "Get": pdu.Type = PduType.Get; dicOID = snmp.Get(version, pdu); break; case "Get Next": pdu.Type = PduType.GetNext; dicOID = snmp.Get(version, pdu); break; case "Get Bulk": pdu.Type = PduType.GetBulk; snmp.MaxRepetitions = 20; dicOID = snmp.Get(version, pdu); break; } if (dicOID != null && dicOID.Count > 0) { this.mgResponseQueue.Enqueue(dicOID); } } }
public VersionCode ToVersionCodeConverter(SnmpVersion version) { switch (version) { case SnmpVersion.V1: return VersionCode.V1; case SnmpVersion.V2: return VersionCode.V2; case SnmpVersion.V3: return VersionCode.V3; default: throw new ArgumentOutOfRangeException(nameof(version), version, null); } }
/// <summary> /// Performs procedure for *QuerySystemData tests. /// </summary> /// <param name="address">The address to test with.</param> /// <param name="snmpVersion">The SNMP protocol version to use.</param> /// <param name="useCache">Value indicating whether to use caching of non-volatile data.</param> /// <param name="allowedApis">The list of allowed APIs</param> private static void QueryAndPrintSystemData(IpAddress address, SnmpVersion snmpVersion, bool useCache = false, QueryApis allowedApis = QueryApis.Snmp) { var querier = SnmpQuerierFactory.Instance.Create(address.ToString(), QuerierOptions.Default.WithProtocolVersion(snmpVersion).WithCaching(useCache).WithAllowedApis(allowedApis)); Assert.NotNull(querier, "Create(...) returned null"); var systemData = querier.SystemData; Assert.NotNull(systemData, "querier.SystemData returned null"); systemData.ForceEvaluateAll(); Console.WriteLine("Obtained system data:"); Console.WriteLine(new BlockTextFormatter().Format(systemData)); }
/// <summary> /// Initializes a new instance of the <see cref="SnmpSimpleDatagram" /> class. /// </summary> /// <param name="snmpDatagramInput">The SNMP datagram input.</param> public SnmpSimpleDatagram(SnmpDatagram snmpDatagramInput) { snmpDatagram = snmpDatagramInput; Version = snmpDatagram.Header.Version; Community = snmpDatagram.Header.Community; PDUType = snmpDatagram.PduV2c.PduType; RequestId = snmpDatagram.PduV2c.RequestId; ErrorStatus = snmpDatagram.PduV2c.ErrorStatus; ErrorIndex = snmpDatagram.PduV2c.ErrorIndex; VarBinds = new List <KeyValuePair <string, object> >(); for (int i = 0; i < snmpDatagram.PduV2c.VarBinds.Count; i++) { var varBind = snmpDatagram.PduV2c.VarBinds[i]; VarBinds.Add(new KeyValuePair <string, object>(varBind.Oid.ToString(), varBind.Value)); } }
/// <summary> /// Initializes a new instance of the <see cref="SnmpSimpleDatagram" /> class. /// </summary> /// <param name="snmpDatagramInput">The SNMP datagram input.</param> public SnmpSimpleDatagram(SnmpDatagram snmpDatagramInput) { snmpDatagram = snmpDatagramInput; Version = snmpDatagram.Header.Version; Community = snmpDatagram.Header.Community; PDUType = snmpDatagram.PduV2c.PduType; RequestId = snmpDatagram.PduV2c.RequestId; ErrorStatus = snmpDatagram.PduV2c.ErrorStatus; ErrorIndex = snmpDatagram.PduV2c.ErrorIndex; VarBinds = new List<KeyValuePair<string, object>>(); for(int i=0 ; i< snmpDatagram.PduV2c.VarBinds.Count; i++) { var varBind = snmpDatagram.PduV2c.VarBinds[i]; VarBinds.Add(new KeyValuePair<string, object>(varBind.Oid.ToString(), varBind.Value)); } }
/// <summary> /// SNMP GET-NEXT request /// </summary> /// <example>SNMP GET-NEXT request: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// // Create a request Pdu /// Pdu pdu = new Pdu(); /// pdu.Type = SnmpConstants.GETNEXT; // type GETNEXT /// pdu.VbList.Add("1.3.6.1.2.1.1"); /// Dictionary<Oid, AsnType> result = snmp.GetNext(pdu); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// foreach (KeyValuePair<Oid, AsnType> entry in result) /// { /// Console.WriteLine("{0} = {1}: {2}", entry.Key.ToString(), SnmpConstants.GetTypeName(entry.Value.Type), /// entry.Value.ToString()); /// } /// } /// </code> /// Will return: /// <code> /// 1.3.6.1.2.1.1.1.0 = OctetString: "Dual core Intel notebook" /// </code> /// </example> /// <param name="version">SNMP protocol version. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="pdu">Request Protocol Data Unit</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary <Oid, AsnType> GetNext(SnmpVersion version, Pdu pdu) { if (!Valid) { return(null); // class is not fully initialized. } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { return(null); } try { _target = new UdpTarget(_peerIP, _peerPort, _timeout, _retry); AgentParameters param = new AgentParameters(version, new OctetString(_community)); SnmpPacket result = _target.Request(pdu, param); if (result != null) { if (result.Pdu.ErrorStatus == 0) { Dictionary <Oid, AsnType> res = new Dictionary <Oid, AsnType>(); foreach (Vb v in result.Pdu.VbList) { if (version == SnmpVersion.Ver2 && (v.Value.Type == SnmpConstants.SMI_ENDOFMIBVIEW) || (v.Value.Type == SnmpConstants.SMI_NOSUCHINSTANCE) || (v.Value.Type == SnmpConstants.SMI_NOSUCHOBJECT)) { break; } res.Add(v.Oid, v.Value); } _target.Close(); _target = null; return(res); } } } catch (Exception ex) { ex.GetType(); // just to stop a warning } _target.Close(); _target = null; return(null); }
/// <summary> /// Performs procedure for *QueryInterfaceData tests. /// </summary> /// <param name="address">The address to test with.</param> /// <param name="snmpVersion">The SNMP protocol version to use.</param> /// <param name="useCache">Value indicating whether to use caching of non-volatile data.</param> /// <param name="allowedApis">The list of allowed APIs</param> private static void QueryAndPrintInterfaces(IpAddress address, SnmpVersion snmpVersion, bool useCache = false, QueryApis allowedApis = QueryApis.Snmp) { var querier = SnmpQuerierFactory.Instance.Create(address.ToString(), QuerierOptions.Default.WithProtocolVersion(snmpVersion).WithCaching(useCache).WithAllowedApis(allowedApis)); Assert.NotNull(querier, "Create(...) returned null"); var networkInterfaceDetails = querier.NetworkInterfaceDetails; Assert.NotNull(networkInterfaceDetails, "querier.NetworkInterfaceDetails returned null"); networkInterfaceDetails.ForceEvaluateAll(); Assert.NotNull(networkInterfaceDetails.Details, "querier.NetworkInterfaceDetails.Details returned null"); Assert.Greater(networkInterfaceDetails.Details.Count, 0, "querier.NetworkInterfaceDetails.Details.Count == 0"); Console.WriteLine("Obtained interface details:"); Console.WriteLine(new BlockTextFormatter().Format(networkInterfaceDetails)); }
/// <summary> /// Performs procedure for BGP tests. /// </summary> /// <param name="address">The address to test with.</param> /// <param name="snmpVersion">The SNMP protocol version to use.</param> /// <param name="useCache">Value indicating whether to use caching of non-volatile data.</param> /// <param name="allowedApis">The list of allowed APIs</param> private static void QueryAndPrintBgpPeers(IpAddress address, SnmpVersion snmpVersion, bool useCache = false, QueryApis allowedApis = QueryApis.VendorSpecific) { var querier = SnmpQuerierFactory.Instance.Create(address.ToString(), QuerierOptions.Default.WithProtocolVersion(snmpVersion).WithCaching(useCache).WithAllowedApis(allowedApis)); var systemData = querier.SystemData; systemData.ForceEvaluateAll(); Assert.NotNull(querier, "Create(...) returned null"); var bgpPeers = querier.FetchBgpPeers(null); Assert.NotNull(bgpPeers, "querier.BgpPeers returned null"); bgpPeers.ForceEvaluateAll(); Console.WriteLine("Obtained BGP peers:"); Console.WriteLine(new BlockTextFormatter().Format(bgpPeers)); }
/// <summary> /// Sets the given protocol version and community. /// </summary> /// <param name="protocolVersion">The new protocol version to use.</param> /// <param name="community">The new communitiy to use.</param> private void SetVersionAndCommunity(SnmpVersion protocolVersion, OctetString community) { if ((this.QueryParameters?.Version == protocolVersion) && (this.QueryParameters?.Community == community)) { #if DEBUG log.Debug($"Device '{this.Address}': SNMP community '{community}' and protocol version '{protocolVersion}' already set. No change."); #endif return; } #if DEBUG log.Debug($"Device '{this.Address}': From now on using SNMP community '{community}' and protocol version '{protocolVersion}'"); #endif this.QueryParameters = new AgentParameters(community) { Version = protocolVersion, DisableReplySourceCheck = true }; }
private void comboBoxVersion_SelectedIndexChanged(object sender, EventArgs e) { SnmpVersion version = (SnmpVersion)((DictionaryEntry)comboBoxVersion.SelectedItem).Value; if (version == SnmpVersion.Ver1 && comboBoxGetStyle.SelectedIndex == 2) { MessageBox.Show("Ver1不支持Bulk...", "提示"); comboBoxVersion.SelectedIndex = 1; } else if (version == SnmpVersion.Ver3 && comboBoxGetStyle.SelectedIndex == 3) { MessageBox.Show("后续版本增加Ver3版本SET支持...", "提示"); comboBoxVersion.SelectedIndex = 0; } else { snmpObj.Version = version; } }
/// <summary> /// SNMP SET request /// </summary> /// <example>Set operation in SNMP version 1: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// // Create a request Pdu /// List<Vb> vbList = new List<Vb>(); /// Oid setOid = new Oid("1.3.6.1.2.1.1.1.0"); // sysDescr.0 /// OctetString setValue = new OctetString("My personal toy"); /// vbList.Add(new Vb(setOid, setValue)); /// Dictionary<Oid, AsnType> result = snmp.Set(SnmpVersion.Ver1, list.ToArray()); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// Console.WriteLine("Success!"); /// } /// </code> /// /// To use SNMP version 2, change snmp.Set() method call first parameter to SnmpVersion.Ver2. /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="vbs">Vb array containing Oid/AsnValue pairs for the SET operation</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary <Oid, AsnType> Set(SnmpVersion version, Vb[] vbs) { if (!Valid) { return(null); } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { return(null); } Pdu pdu = new Pdu(PduType.Set); foreach (Vb vb in vbs) { pdu.VbList.Add(vb); } return(Set(version, pdu)); }
/// <summary> /// SNMP GET-NEXT request /// </summary> /// <example>SNMP GET-NEXT request: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// Dictionary<Oid, AsnType> result = snmp.GetNext(SnmpVersion.Ver1, new string[] { "1.3.6.1.2.1.1" }); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// foreach (KeyValuePair<Oid, AsnType> entry in result) /// { /// Console.WriteLine("{0} = {1}: {2}", entry.Key.ToString(), SnmpConstants.GetTypeName(entry.Value.Type), /// entry.Value.ToString()); /// } /// } /// </code> /// Will return: /// <code> /// 1.3.6.1.2.1.1.1.0 = OctetString: "Dual core Intel notebook" /// </code> /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="oidList">List of request OIDs in string dotted decimal format.</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary <Oid, AsnType> GetNext(SnmpVersion version, string[] oidList) { if (!Valid) { return(null); } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { return(null); } Pdu pdu = new Pdu(PduType.GetNext); foreach (string s in oidList) { pdu.VbList.Add(s); } return(GetNext(version, pdu)); }
/// <summary> /// 构造函数 /// </summary> /// <param name="peerName">节点主机名</param> /// <param name="peerPort">端口</param> /// <param name="community">社区名</param> /// <param name="SnmpVersion">SNMP协议版本</param> public SnmpHelper(String peerName, Int32 peerPort, String community, Int32 SnmpVersion) { this.PeerName = peerName; this.PeerPort = peerPort; this.Community = community; switch (SnmpVersion) { case 1: this.SnmpVersion = SnmpSharpNet.SnmpVersion.Ver1; break; case 2: this.SnmpVersion = SnmpSharpNet.SnmpVersion.Ver2; break; case 3: this.SnmpVersion = SnmpSharpNet.SnmpVersion.Ver3; break; } SimpleSnmp = new SimpleSnmp(peerName, peerPort, community); }
/// <summary> /// SNMP SET request /// </summary> /// <example>Set operation in SNMP version 1: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// // Create a request Pdu /// Pdu pdu = new Pdu(); /// pdu.Type = SnmpConstants.SET; // type SET /// Oid setOid = new Oid("1.3.6.1.2.1.1.1.0"); // sysDescr.0 /// OctetString setValue = new OctetString("My personal toy"); /// pdu.VbList.Add(setOid, setValue); /// Dictionary<Oid, AsnType> result = snmp.Set(SnmpVersion.Ver1, pdu); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// Console.WriteLine("Success!"); /// } /// </code> /// /// To use SNMP version 2, change snmp.Set() method call first parameter to SnmpVersion.Ver2. /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="pdu">Request Protocol Data Unit</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary <Oid, AsnType> Set(SnmpVersion version, Pdu pdu) { if (!Valid) { return(null); // class is not fully initialized. } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { return(null); } try { _target = new UdpTarget(_peerIP, _peerPort, _timeout, _retry); AgentParameters param = new AgentParameters(version, new OctetString(_community)); SnmpPacket result = _target.Request(pdu, param); if (result != null) { if (result.Pdu.ErrorStatus == 0) { Dictionary <Oid, AsnType> res = new Dictionary <Oid, AsnType>(); foreach (Vb v in result.Pdu.VbList) { res.Add(v.Oid, v.Value); } _target.Close(); _target = null; return(res); } } } catch { } _target.Close(); _target = null; return(null); }
private static Oid[] ProcessSnmpv1EndOfMIB(SnmpVersion version, Oid[] columnOids, Pdu request, SnmpException e) { int index = 0; if (version == SnmpVersion.SNMPv1 && e.ErrorStatus == SnmpError.NoSuchName && (index = e.ErrorIndex) > 0 && index <= request.Count) { index--; for (int i = 0, j = 0; i < columnOids.Length; i++) { if (columnOids[i] != null && j++ == index) { columnOids[i] = null; break; } } Vb[] vbs = request.Vbs; Oid[] oids = new Oid[vbs.Length - 1]; for (int i = 0; i < index; i++) { oids[i] = vbs[i].Oid; } for (int i = index; i < oids.Length; i++) { oids[i] = vbs[i + 1].Oid; } return(oids); } else { return(null); } }
/// <summary>SNMP WALK operation</summary> /// <remarks> /// When using SNMP version 1, walk is performed using GET-NEXT calls. When using SNMP version 2, /// walk is performed using GET-BULK calls. /// </remarks> /// <example>Example SNMP walk operation using SNMP version 1: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// Dictionary<Oid, AsnType> result = snmp.Walk(SnmpVersion.Ver1, "1.3.6.1.2.1.1"); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// foreach (KeyValuePair<Oid, AsnType> entry in result) /// { /// Console.WriteLine("{0} = {1}: {2}", entry.Key.ToString(), SnmpConstants.GetTypeName(entry.Value.Type), /// entry.Value.ToString()); /// } /// </code> /// Will return: /// <code> /// 1.3.6.1.2.1.1.1.0 = OctetString: "Dual core Intel notebook" /// 1.3.6.1.2.1.1.2.0 = ObjectId: 1.3.6.1.9.233233.1.1 /// 1.3.6.1.2.1.1.3.0 = TimeTicks: 0d 0h 0m 1s 420ms /// 1.3.6.1.2.1.1.4.0 = OctetString: "*****@*****.**" /// 1.3.6.1.2.1.1.5.0 = OctetString: "milans-nbook" /// 1.3.6.1.2.1.1.6.0 = OctetString: "Developer home" /// 1.3.6.1.2.1.1.8.0 = TimeTicks: 0d 0h 0m 0s 10ms /// </code> /// /// To use SNMP version 2, change snmp.Set() method call first parameter to SnmpVersion.Ver2. /// </example> /// <param name="version">SNMP protocol version. Acceptable values are SnmpVersion.Ver1 and /// SnmpVersion.Ver2</param> /// <param name="rootOid">OID to start WALK operation from. Only child OIDs of the rootOid will be /// retrieved and returned</param> /// <param name="tryGetBulk">this param is used to use get bulk on V2 requests</param> /// <returns>Oid => AsnType value mappings on success, empty dictionary if no data was found or /// null on error</returns> public Dictionary<Oid, AsnType> Walk(bool tryGetBulk, SnmpVersion version, string rootOid) { if (!Valid) { if (!_suppressExceptions) { throw new SnmpException("SimpleSnmp class is not valid."); } return null; } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { if (!_suppressExceptions) { throw new SnmpInvalidVersionException("SimpleSnmp support SNMP version 1 and 2 only."); } return null; } if (rootOid.Length < 2) { if (!_suppressExceptions) { throw new SnmpException(SnmpException.InvalidOid, "RootOid is not a valid Oid"); } return null; } Oid root = new Oid(rootOid); if (root.Length <= 0) { return null; // unable to parse root oid } Oid lastOid = (Oid)root.Clone(); Dictionary<Oid, AsnType> result = new Dictionary<Oid, AsnType>(); while (lastOid != null && root.IsRootOf(lastOid)) { Dictionary<Oid, AsnType> val = null; if (version == SnmpVersion.Ver1) { val = GetNext(version, new string[] { lastOid.ToString() }); } else { if (tryGetBulk == true) { val = GetBulk(new string[] { lastOid.ToString() }); } else { val = GetNext(version, new string[] { lastOid.ToString() }); } } // check that we have a result if (val == null) { // error of some sort happened. abort... return null; } foreach (KeyValuePair<Oid, AsnType> entry in val) { if (root.IsRootOf(entry.Key)) { if (result.ContainsKey(entry.Key)) { if (result[entry.Key].Type != entry.Value.Type) { throw new SnmpException(SnmpException.OidValueTypeChanged, "OID value type changed for OID: " + entry.Key.ToString()); } else result[entry.Key] = entry.Value; } else { result.Add(entry.Key, entry.Value); } lastOid = (Oid)entry.Key.Clone(); } else { // it's faster to check if variable is null then checking IsRootOf lastOid = null; break; } } } return result; }
/// <summary> /// SNMP GET-NEXT request /// </summary> /// <example>SNMP GET-NEXT request: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// Dictionary<Oid, AsnType> result = snmp.GetNext(SnmpVersion.Ver1, new string[] { "1.3.6.1.2.1.1" }); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// foreach (KeyValuePair<Oid, AsnType> entry in result) /// { /// Console.WriteLine("{0} = {1}: {2}", entry.Key.ToString(), SnmpConstants.GetTypeName(entry.Value.Type), /// entry.Value.ToString()); /// } /// } /// </code> /// Will return: /// <code> /// 1.3.6.1.2.1.1.1.0 = OctetString: "Dual core Intel notebook" /// </code> /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="oidList">List of request OIDs in string dotted decimal format.</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary<Oid, AsnType> GetNext(SnmpVersion version, string[] oidList) { if (!Valid) { if (!_suppressExceptions) { throw new SnmpException("SimpleSnmp class is not valid."); } return null; } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { if (!_suppressExceptions) { throw new SnmpInvalidVersionException("SimpleSnmp support SNMP version 1 and 2 only."); } return null; } Pdu pdu = new Pdu(PduType.GetNext); foreach (string s in oidList) { pdu.VbList.Add(s); } return GetNext(version, pdu); }
/// <summary> /// SNMP GET request /// </summary> /// <example>SNMP GET request: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "public"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// // Create a request Pdu /// Pdu pdu = new Pdu(); /// pdu.Type = SnmpConstants.GET; // type GET /// pdu.VbList.Add("1.3.6.1.2.1.1.1.0"); /// Dictionary<Oid, AsnType> result = snmp.GetNext(SnmpVersion.Ver1, pdu); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// foreach (KeyValuePair<Oid, AsnType> entry in result) /// { /// Console.WriteLine("{0} = {1}: {2}", entry.Key.ToString(), SnmpConstants.GetTypeName(entry.Value.Type), /// entry.Value.ToString()); /// } /// } /// </code> /// Will return: /// <code> /// 1.3.6.1.2.1.1.1.0 = OctetString: "Dual core Intel notebook" /// </code> /// </example> /// <param name="version">SNMP protocol version. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="pdu">Request Protocol Data Unit</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary<Oid, AsnType> Get(SnmpVersion version, Pdu pdu) { if (!Valid) { if (!_suppressExceptions) { throw new SnmpException("SimpleSnmp class is not valid."); } return null; // class is not fully initialized. } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { if (!_suppressExceptions) { throw new SnmpInvalidVersionException("SimpleSnmp support SNMP version 1 and 2 only."); } return null; } try { _target = new UdpTarget(_peerIP, _peerPort, _timeout, _retry); } catch( Exception ex ) { _target = null; if (!_suppressExceptions) { throw ex; } } if( _target == null ) { return null; } try { AgentParameters param = new AgentParameters(version, new OctetString(_community)); SnmpPacket result = _target.Request(pdu, param); if (result != null) { if (result.Pdu.ErrorStatus == 0) { Dictionary<Oid, AsnType> res = new Dictionary<Oid, AsnType>(); foreach (Vb v in result.Pdu.VbList) { if (version == SnmpVersion.Ver2 && (v.Value.Type == SnmpConstants.SMI_NOSUCHINSTANCE || v.Value.Type == SnmpConstants.SMI_NOSUCHOBJECT)) { if (!res.ContainsKey(v.Oid)) { res.Add(v.Oid, new Null()); } else { res.Add(Oid.NullOid(), v.Value); } } else { if (!res.ContainsKey(v.Oid)) { res.Add(v.Oid, v.Value); } else { if (res[v.Oid].Type == v.Value.Type) { res[v.Oid] = v.Value; // update value of the existing Oid entry } else { throw new SnmpException(SnmpException.OidValueTypeChanged, String.Format("Value type changed from {0} to {1}", res[v.Oid].Type, v.Value.Type)); } } } } _target.Close(); _target = null; return res; } else { if (!_suppressExceptions) { throw new SnmpErrorStatusException("Agent responded with an error", result.Pdu.ErrorStatus, result.Pdu.ErrorIndex); } } } } catch( Exception ex ) { if( ! _suppressExceptions ) { _target.Close(); _target = null; throw ex; } } _target.Close(); _target = null; return null; }
/// <summary> /// Creates a new object that is a copy of this object with modified SNMP protocol version. /// </summary> /// <param name="protocolVersion">The new SNMP protocol version to use for the queries.</param> /// <returns>A new object that is a copy of this object with modified SNMP protocol version.</returns> public QuerierOptions WithProtocolVersion(SnmpVersion protocolVersion) { return(new QuerierOptions(this.Port, protocolVersion, this.Community, this.Timeout, this.Retries, this.Ver2cMaximumValuesPerRequest, this.Ver2cMaximumRequests, this.EnableCaching, this.LoginUser, this.LoginPassword, this.AllowedApis)); }
/// <summary> /// Constructor /// </summary> /// <param name="version">SNMP Protocol version</param> /// <param name="community">SNMP community name</param> /// <param name="disableReplySourceCheck">Should reply source IP address/port number be checked on reply reception</param> public AgentParameters(SnmpVersion version, OctetString community, bool disableReplySourceCheck) : this(version, community) { _disableReplySourceCheck = disableReplySourceCheck; }
/// <summary> /// Initializes a new instance of the <see cref="SnmpHeader" /> struct. /// </summary> /// <param name="version">The Snmp version.</param> /// <param name="community">The Snmp Community.</param> public SnmpHeader(SnmpVersion version, string community) { this.Version = version; this.Community = community; }
/// <summary> /// Constructor /// </summary> /// <param name="version">SNMP Protocol version</param> /// <param name="community">SNMP community name</param> public AgentParameters(SnmpVersion version, OctetString community) : this(version) { _community.Set(community); }
private IEnumerable<SnmpResult> WalkOperation(SnmpVersion version, IPAddress ipAddress, string octetString, Oid oid, WalkingMode walkMode) { _log.Info("SnmpEngine.WalkOperation(): Started"); List<SnmpResult> result; try { if (_timeOut == 0) { _timeOut = SnmpHelper.DefaultTimeOut; } if (string.IsNullOrEmpty(octetString)) { octetString = SnmpHelper.DefaultOctetString; } result = oid.HasChildOids ? Walk(version, ipAddress, octetString, oid, walkMode).ToList() : WalkSingle(version, ipAddress, octetString, oid, walkMode).ToList(); } catch (Exception e) { if (e is TimeoutException) { _log.Error("SnmpEngine.WalkOperation():Timeout Exception caught:", e); throw new SnmpTimeOutException(e.Message, _timeOut); } else if (e is ArgumentOutOfRangeException) { _log.Error("SnmpEngine.WalkOperation():Argument Out Of Range Exception caught:", e); throw new SnmpEngineConvertorException((ArgumentOutOfRangeException)e); } else { _log.Error("SnmpEngine.WalkOperation():Exception caught:", e); throw new SnmpEngineException(e.Message); } } finally { _log.Info("SnmpEngine.WalkOperation(): Finished"); } return result; }
private IEnumerable<SnmpResult> GetNextOperation(SnmpVersion version, IPAddress ipAddress, string octetString, Oid oid) { _log.Info("SnmpEngine.GetNextOperation() : Started oid: " + oid.Value); List<SnmpResult> results; var variable = new List<Variable> { new Variable(new ObjectIdentifier(oid.Value)) }; try { var getNextRequest = new GetNextRequestMessage(0, _converter.ToVersionCodeConverter(version), new OctetString(octetString), variable); var responce = getNextRequest.GetResponse(SnmpHelper.DefaultTimeOut, new IPEndPoint(ipAddress, SnmpHelper.SnmpServerPort)); if (responce.Pdu().ErrorStatus.ToInt32() != 0) { throw new SnmpEngineException("SnmpEngine.GetNextOperation() error status = 0; oid = " + oid.Value); } results = responce.Pdu().Variables.Select(var => new SnmpResult(new Oid(var.Id.ToString()), var.Data, _converter.ToSnmpDataType(var.Data.TypeCode))).ToList(); } catch (Exception e) { if (e is TimeoutException) { _log.Error("SnmpEngine.GetOperation():Timeout Exception caught:", e); throw new SnmpTimeOutException(e.Message, _timeOut); } else if (e is ArgumentOutOfRangeException) { _log.Error("SnmpEngine.GetOperation():Argument Out Of Range Exception caught:", e); throw new SnmpEngineConvertorException((ArgumentOutOfRangeException)e); } else { _log.Error("SnmpEngine.GetOperation():Exception caught:", e); throw new SnmpEngineException(e.Message); } } finally { _log.Info("SnmpEngine.GetNextOperation(): Finished"); } return results; }
private IEnumerable<SnmpResult> GetOperation(SnmpVersion version, IPAddress ipAddress, string octetString, Oid oid) { _log.Info("SnmpEngine.GetOperation(): Started"); var variables = new List<Variable> { new Variable(new ObjectIdentifier(oid.Value)) }; try { if (_timeOut == 0) { _timeOut = SnmpHelper.DefaultTimeOut; } if (string.IsNullOrEmpty(octetString)) { octetString = SnmpHelper.DefaultOctetString; } Messenger.Get(_converter.ToVersionCodeConverter(version), new IPEndPoint(ipAddress, SnmpHelper.SnmpServerPort), new OctetString(octetString), variables, _timeOut); } catch (Exception e) { if (e is TimeoutException) { _log.Error("SnmpEngine.GetOperation():Timeout Exception caught:", e); throw new SnmpTimeOutException(e.Message, _timeOut); } else if (e is ArgumentOutOfRangeException) { _log.Error("SnmpEngine.GetOperation():Argument Out Of Range Exception caught:", e); throw new SnmpEngineConvertorException((ArgumentOutOfRangeException)e); } else { _log.Error("SnmpEngine.GetOperation():Exception caught:", e); throw new SnmpEngineException(e.Message); } } finally { _log.Info("SnmpEngine.GetOperation(): Finished"); } return variables.Select(var => new SnmpResult(new Oid(var.Id.ToString()), var.Data, _converter.ToSnmpDataType(var.Data.TypeCode))); }
private List<SnmpResult> WalkWithAdditionalCodes(SnmpVersion version, IPAddress ipAddress, string octetString, Oid oid, WalkingMode walkMode) { _log.Info("SnmpEngine.WalkWithAdditionalCodes(): Started oid: " + oid.Value); var list = new List<Variable>(); var results = new List<SnmpResult>(); var codesTable = XmlLoader.InitAdditionalCodes(oid); var codes = (Codes)codesTable[oid.Name]; if (codes != null) { foreach (var code in codes.Code) { try { Messenger.Walk(_converter.ToVersionCodeConverter(version), new IPEndPoint(ipAddress, SnmpHelper.SnmpServerPort), new OctetString(octetString), new ObjectIdentifier(string.Concat(oid.Value, ".", code.Decimal)), list, _timeOut, _converter.ToWalkModeConverter(walkMode)); } catch (Exception e) { _log.Error("SnmpEngine.WalkWithAdditionalCodes(): Exception caught:", e); _log.Error("SnmpEngine.WalkWithAdditionalCodes(): Exception oid: " + string.Concat(oid.Value, ".", code.Decimal)); } if (list.Any()) { _log.Info("SnmpEngine.WalkWithAdditionalCodes(): sucess oid: " + string.Concat(oid.Value, ".", code.Decimal)); _log.Info("SnmpEngine.WalkWithAdditionalCodes(): request result oids: " + list.Count); results.AddRange(list.Select(var => new SnmpResult(new Oid(string.Concat(oid.Value, ".", code.Decimal), code.Name, string.Concat(oid.FullName, ".", code.Name)), var.Data, _converter.ToSnmpDataType(var.Data.TypeCode)))); list.Clear(); } } } codesTable.Clear(); _log.Info("SnmpEngine.WalkWithAdditionalCodes(): Finished"); return results; }
private IEnumerable<SnmpResult> WalkSingle(SnmpVersion version, IPAddress ipAddress, string octetString, Oid oid, WalkingMode walkMode) { _log.Info("SnmpEngine.WalkSingle(): Started oid: " + oid.Value); var list = new List<Variable>(); if (oid.HasAdditionalCodes) { return WalkWithAdditionalCodes(version, ipAddress, octetString, oid, walkMode); } try { Messenger.Walk( _converter.ToVersionCodeConverter(version), new IPEndPoint(ipAddress, SnmpHelper.SnmpServerPort), new OctetString(octetString), new ObjectIdentifier(oid.Value), list, _timeOut, _converter.ToWalkModeConverter(walkMode)); } catch (Exception e) { _log.Error("SnmpEngine.WalkSingle(): Exception caught: ", e); _log.Error("SnmpEngine.WalkSingle(): Exception oid: " + oid.Value); } _log.Info("SnmpEngine.WalkSingle(): Finished"); return list.Select(var => new SnmpResult(new Oid(var.Id.ToString()), var.Data, _converter.ToSnmpDataType(var.Data.TypeCode))); }
private IEnumerable<SnmpResult> WalkBulk(SnmpVersion version, IPAddress ipAddress, int maxBulkRepetitions, string octetString, Oid oid, WalkingMode walkMode) { _log.Info("SnmpEngine.WalkBulk(): Started oid: " + oid.Value); var result = new List<SnmpResult>(); foreach (var childOid in oid.ChildOids) { result.AddRange(!childOid.HasChildOids ? WalkBulkSingle(version, ipAddress, maxBulkRepetitions, octetString, childOid, walkMode) : WalkBulk(version, ipAddress, maxBulkRepetitions, octetString, childOid, walkMode)); } _log.Info("SnmpEngine.WalkBulk(): Finished"); return result; }
/// <summary> /// Initializes a new instance of the <see cref="SnmpHeader" /> struct. /// </summary> /// <param name="version">The Snmp version.</param> /// <param name="community">The Snmp Community.</param> public SnmpHeader(SnmpVersion version, string community) { Version = version; Community = community; }
/// <summary> /// Initializes a new instance of the <see cref="SnmpDatagram"/> class. /// </summary> /// <param name="pduType">Type of the pdu.</param> /// <param name="snmpVersion">The SNMP version.</param> /// <param name="community">The community.</param> /// <param name="enterprise">The enterprise.</param> /// <param name="agentAddress">The agent address.</param> /// <param name="genericV1Trap">The generic v1 trap.</param> /// <param name="specificTrap">The specific trap.</param> /// <param name="timeStamp">The time stamp.</param> /// <param name="varBinds">The variable binds.</param> public SnmpDatagram(PduType pduType, SnmpVersion snmpVersion, string community, ObjectIdentifier enterprise, IPAddress agentAddress, GenericTrap genericV1Trap, int specificTrap, uint timeStamp, VarBind[] varBinds) { Header = new SnmpHeader(snmpVersion, community); PduV1 = new SnmpV1PDU(pduType, enterprise, agentAddress, genericV1Trap, specificTrap, timeStamp, varBinds); PduV2c = default(SnmpV2cPDU); }
/// <summary> /// Constructor. Initialize SNMP version as supplied. /// </summary> /// <param name="protocolVersion">Protocol version. Acceptable values are SnmpConstants.SNMPV1, /// SnmpConstants.SNMPV2 and SnmpConstants.SNMPV3</param> public SnmpPacket(SnmpVersion protocolVersion) { _protocolVersion = new Integer32((int)protocolVersion); }
/// <summary> /// Constructor /// </summary> /// <param name="version">SNMP protocol version. Acceptable values are SnmpConstants.SNMPV1 and /// SnmpConstants.SNMPV2</param> public AgentParameters(SnmpVersion version) : this() { _version.Value = (int)version; }
/// <summary> /// SNMP SET request /// </summary> /// <example>Set operation in SNMP version 1: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// // Create a request Pdu /// List<Vb> vbList = new List<Vb>(); /// Oid setOid = new Oid("1.3.6.1.2.1.1.1.0"); // sysDescr.0 /// OctetString setValue = new OctetString("My personal toy"); /// vbList.Add(new Vb(setOid, setValue)); /// Dictionary<Oid, AsnType> result = snmp.Set(SnmpVersion.Ver1, list.ToArray()); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// Console.WriteLine("Success!"); /// } /// </code> /// /// To use SNMP version 2, change snmp.Set() method call first parameter to SnmpVersion.Ver2. /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="vbs">Vb array containing Oid/AsnValue pairs for the SET operation</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary<Oid, AsnType> Set(SnmpVersion version, Vb[] vbs) { if (!Valid) { if (!_suppressExceptions) { throw new SnmpException("SimpleSnmp class is not valid."); } return null; } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { if (!_suppressExceptions) { throw new SnmpInvalidVersionException("SimpleSnmp support SNMP version 1 and 2 only."); } return null; } Pdu pdu = new Pdu(PduType.Set); foreach (Vb vb in vbs) { pdu.VbList.Add(vb); } return Set(version, pdu); }
/// <summary> /// Tries to obtain the oid lookup table given lookup ID. /// </summary> /// <param name="context">The device database context to extend.</param> /// <param name="oidLookupId">The OID mapping lookup ID to get.</param> /// <param name="maximumSupportedSnmpVersion">The maximum supported SNMP version (to put into returned lookup)</param> /// <param name="oidLookup">Returns the OID lookup, if found.</param> /// <returns><c>true</c> if a lookup of the given lookup ID has been found and the ID returned. Otherwise <c>false</c>.</returns> public static bool TryFindDeviceSpecificOidLookup(this DeviceDatabaseContext context, int oidLookupId, SnmpVersion maximumSupportedSnmpVersion, out IDeviceSpecificOidLookup oidLookup) { if (context == null) { throw new ArgumentNullException(nameof(context), "The context to search OID lookup is null"); } oidLookup = null; var result = context.DeviceSpecificOids.Where(d => d.OidMappingId == oidLookupId); if (!result.Any()) { return(false); } oidLookup = new DeviceSpecificOidLookup(result, maximumSupportedSnmpVersion); return(true); }
/// <summary> /// SNMP SET request /// </summary> /// <example>Set operation in SNMP version 1: /// <code> /// String snmpAgent = "10.10.10.1"; /// String snmpCommunity = "private"; /// SimpleSnmp snmp = new SimpleSnmp(snmpAgent, snmpCommunity); /// // Create a request Pdu /// Pdu pdu = new Pdu(); /// pdu.Type = SnmpConstants.SET; // type SET /// Oid setOid = new Oid("1.3.6.1.2.1.1.1.0"); // sysDescr.0 /// OctetString setValue = new OctetString("My personal toy"); /// pdu.VbList.Add(setOid, setValue); /// Dictionary<Oid, AsnType> result = snmp.Set(SnmpVersion.Ver1, pdu); /// if( result == null ) { /// Console.WriteLine("Request failed."); /// } else { /// Console.WriteLine("Success!"); /// } /// </code> /// /// To use SNMP version 2, change snmp.Set() method call first parameter to SnmpVersion.Ver2. /// </example> /// <param name="version">SNMP protocol version number. Acceptable values are SnmpVersion.Ver1 and SnmpVersion.Ver2</param> /// <param name="pdu">Request Protocol Data Unit</param> /// <returns>Result of the SNMP request in a dictionary format with Oid => AsnType values</returns> public Dictionary<Oid, AsnType> Set(SnmpVersion version, Pdu pdu) { if (!Valid) { if (!_suppressExceptions) { throw new SnmpException("SimpleSnmp class is not valid."); } return null; // class is not fully initialized. } // function only works on SNMP version 1 and SNMP version 2 requests if (version != SnmpVersion.Ver1 && version != SnmpVersion.Ver2) { if (!_suppressExceptions) { throw new SnmpInvalidVersionException("SimpleSnmp support SNMP version 1 and 2 only."); } return null; } try { _target = new UdpTarget(_peerIP, _peerPort, _timeout, _retry); } catch(Exception ex) { _target = null; if( ! _suppressExceptions) { throw ex; } } if( _target == null ) { return null; } try { AgentParameters param = new AgentParameters(version, new OctetString(_community)); SnmpPacket result = _target.Request(pdu, param); if (result != null) { if (result.Pdu.ErrorStatus == 0) { Dictionary<Oid, AsnType> res = new Dictionary<Oid, AsnType>(); foreach (Vb v in result.Pdu.VbList) { if (res.ContainsKey(v.Oid)) { if (res[v.Oid].Type != v.Value.Type) { throw new SnmpException(SnmpException.OidValueTypeChanged, "OID value type changed for OID: " + v.Oid.ToString()); } else { res[v.Oid] = v.Value; } } else { res.Add(v.Oid, v.Value); } } _target.Close(); _target = null; return res; } else { if( ! _suppressExceptions ) { throw new SnmpErrorStatusException("Agent responded with an error", result.Pdu.ErrorStatus, result.Pdu.ErrorIndex); } } } } catch(Exception ex) { if( ! _suppressExceptions ) { _target.Close(); _target = null; throw ex; } } _target.Close(); _target = null; return null; }
/// <summary> /// Initializes a new instance of the <see cref="SnmpDatagram"/> class. /// </summary> /// <param name="pduType">Type of the pdu.</param> /// <param name="snmpVersion">The SNMP version.</param> /// <param name="community">The community.</param> /// <param name="requestId">The request identifier.</param> /// <param name="errorStatus">The error status.</param> /// <param name="errorIndex">Index of the error.</param> /// <param name="varBinds">The variable binds.</param> public SnmpDatagram(PduType pduType, SnmpVersion snmpVersion, string community, int requestId, SnmpErrorStatus errorStatus, int errorIndex, VarBind[] varBinds) { Header = new SnmpHeader(snmpVersion, community); PduV2c = new SnmpV2cPDU(pduType, requestId, errorStatus, errorIndex, varBinds); PduV1 = default(SnmpV1PDU); }