/// <summary> /// Creates the specified request. /// </summary> /// <param name="request">The request.</param> /// <param name="sender">The sender.</param> /// <param name="users">The users.</param> /// <param name="group">The engine group.</param> /// <param name="binding">The binding.</param> /// <returns></returns> public static ISnmpContext Create(ISnmpMessage request, IPEndPoint sender, UserRegistry users, EngineGroup group, IListenerBinding binding) { if (request.Version == VersionCode.V3) { return(new SecureSnmpContext(request, sender, users, group, binding)); } return(new NormalSnmpContext(request, sender, users, binding)); }
/// <summary> /// Initializes a new instance of the <see cref="SnmpContextBase"/> class. /// </summary> /// <param name="request">The request.</param> /// <param name="sender">The sender.</param> /// <param name="users">The users.</param> /// <param name="group">The engine core group.</param> /// <param name="binding">The binding.</param> protected SnmpContextBase(ISnmpMessage request, IPEndPoint sender, UserRegistry users, EngineGroup group, IListenerBinding binding) { Request = request; Binding = binding; Users = users; Sender = sender; CreatedTime = DateTime.Now; Group = group; }
/// <summary> /// Gets the message ID. /// </summary> /// <value>The message ID.</value> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> /// <remarks>For v3, message ID is different from request ID. For v1 and v2c, they are the same.</remarks> public static int MessageId(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } return(message.Header == Header.Empty ? message.RequestId() : message.Header.MessageId); }
/// <summary> /// Request ID. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> public static int RequestId(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } return(message.Scope.Pdu.RequestId.ToInt32()); }
/// <summary> /// Gets the <see cref="SnmpType"/>. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> /// <returns></returns> public static SnmpType TypeCode(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } return(message.Pdu().TypeCode); }
/// <summary> /// Creates a <see cref="ErrorException"/>. /// </summary> /// <param name="message">Message.</param> /// <param name="agent">Agent address.</param> /// <param name="body">Error message body.</param> /// <returns></returns> public static ErrorException Create(string message, IPAddress agent, ISnmpMessage body) { var ex = new ErrorException(message) { Agent = agent, Body = body }; return(ex); }
private ErrorException(SerializationInfo info, StreamingContext context) : base(info, context) { if (info == null) { throw new ArgumentNullException("info"); } Body = (ResponseMessage)info.GetValue("Body", typeof(ResponseMessage)); }
/// <summary> /// PDU. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> public static ISnmpPdu Pdu(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } return(message.Scope.Pdu); }
/// <summary> /// Community name. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> public static OctetString Community(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } return(message.Parameters.UserName ?? OctetString.Empty); }
/// <summary> /// Creates the specified request. /// </summary> /// <param name="request">The request.</param> /// <param name="sender">The sender.</param> /// <param name="users">The users.</param> /// <param name="group">The engine group.</param> /// <param name="binding">The binding.</param> /// <returns></returns> public static SnmpContext Create(ISnmpMessage request, IPEndPoint sender, UserRegistry users, EngineGroup group, IListenerBinding binding) { if (request.Version == VersionCode.V3) { return new SecureSnmpContext(request, sender, users, group, binding); } return new NormalSnmpContext(request, sender, users, binding); }
/// <summary> /// Gets the handler. /// </summary> /// <param name="message">The message.</param> /// <returns></returns> public IMessageHandler GetHandler(ISnmpMessage message) { foreach (var mapping in _mappings.Where(mapping => mapping.CanHandle(message))) { return mapping.Handler; } return _nullHandler; }
/// <summary> /// Gets the handler. /// </summary> /// <param name="message">The message.</param> /// <returns></returns> public IMessageHandler GetHandler(ISnmpMessage message) { foreach (var mapping in _mappings.Where(mapping => mapping.CanHandle(message))) { return(mapping.Handler); } return(_nullHandler); }
/// <summary> /// Packs up the <see cref="ISnmpMessage"/>. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> /// <param name="length">The length bytes.</param> /// <returns></returns> internal static Sequence PackMessage(this ISnmpMessage message, byte[] length) { if (message == null) { throw new ArgumentNullException("message"); } return(ByteTool.PackMessage(length, message.Version, message.Header, message.Parameters, message.Privacy.GetScopeData(message.Header, message.Parameters, message.Scope.GetData(message.Version)))); }
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()); }
/// <summary> /// Begins to asynchronously send an <see cref="ISnmpMessage"/> to an <see cref="IPEndPoint"/>. /// </summary> /// <param name="request">The <see cref="ISnmpMessage"/>.</param> /// <param name="receiver">Agent.</param> /// <param name="registry">The user registry.</param> /// <param name="udpSocket">The UDP <see cref="Socket"/> to use to send/receive.</param> /// <param name="callback">The callback.</param> /// <param name="state">The state object.</param> /// <returns></returns> public static IAsyncResult BeginGetResponse( this ISnmpMessage request, IPEndPoint receiver, UserRegistry registry, Socket udpSocket, AsyncCallback callback, object state) { if (request == null) { throw new ArgumentNullException("request"); } if (udpSocket == null) { throw new ArgumentNullException("udpSocket"); } if (receiver == null) { throw new ArgumentNullException("receiver"); } if (registry == null) { throw new ArgumentNullException("registry"); } var requestCode = request.TypeCode(); if (requestCode == SnmpType.TrapV1Pdu || requestCode == SnmpType.TrapV2Pdu || requestCode == SnmpType.ReportPdu) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "not a request message: {0}", requestCode)); } // Whatever you change, try to keep the Send and the Receive close to each other. udpSocket.SendTo(request.ToBytes(), receiver); #if CF var bufferSize = 8192; #elif SSHARP var bufferSize = 16384; #else var bufferSize = udpSocket.ReceiveBufferSize = Messenger.MaxMessageSize; #endif var buffer = new byte[bufferSize]; // https://sharpsnmplib.codeplex.com/workitem/7234 if (callback != null) { AsyncCallback wrapped = callback; callback = asyncResult => { var result = new SnmpMessageAsyncResult(asyncResult, udpSocket, registry, receiver, buffer); wrapped(result); }; } var ar = udpSocket.BeginReceive(buffer, 0, bufferSize, SocketFlags.None, callback, state); return(new SnmpMessageAsyncResult(ar, udpSocket, registry, receiver, buffer)); }
/// <summary> /// Sends this <see cref="ISnmpMessage"/> and handles the response from agent. /// </summary> /// <param name="request">The <see cref="ISnmpMessage"/>.</param> /// <param name="timeout">The time-out value, in milliseconds. The default value is 0, which indicates an infinite time-out period. Specifying -1 also indicates an infinite time-out period.</param> /// <param name="receiver">Agent.</param> /// <param name="udpSocket">The UDP <see cref="Socket"/> to use to send/receive.</param> /// <returns></returns> public static ISnmpMessage GetResponse(this ISnmpMessage request, int timeout, IPEndPoint receiver, Socket udpSocket) { UserRegistry registry = new UserRegistry(); if (request.Version == VersionCode.V3) { registry.Add(request.Parameters.UserName, request.Privacy); } return(request.GetResponse(timeout, receiver, registry, udpSocket)); }
public InformRequestMessage( VersionCode version, int messageId, int requestId, OctetString userName, ObjectIdentifier enterprise, uint time, IList <Variable> variables, IPrivacyProvider privacy, int maxMessageSize, ISnmpMessage report) { if (userName == null) { throw new ArgumentNullException("userName"); } if (variables == null) { throw new ArgumentNullException("variables"); } if (version != VersionCode.V3) { throw new ArgumentException("only v3 is supported", "version"); } if (enterprise == null) { throw new ArgumentNullException("enterprise"); } if (report == null) { throw new ArgumentNullException("report"); } if (privacy == null) { throw new ArgumentNullException("privacy"); } Version = version; Privacy = privacy; Enterprise = enterprise; TimeStamp = time; Header = new Header(new Integer32(messageId), new Integer32(maxMessageSize), privacy.ToSecurityLevel() | Levels.Reportable); var parameters = report.Parameters; var authenticationProvider = Privacy.AuthenticationProvider; Parameters = new SecurityParameters(parameters.EngineId, parameters.EngineBoots, parameters.EngineTime, userName, authenticationProvider.CleanDigest, Privacy.Salt); var pdu = new InformRequestPdu(requestId, enterprise, time, variables); var scope = report.Scope; var contextEngineId = scope.ContextEngineId == OctetString.Empty ? parameters.EngineId : scope.ContextEngineId; Scope = new Scope(contextEngineId, scope.ContextName, pdu); authenticationProvider.ComputeHash(Version, Header, Parameters, Scope, Privacy); _bytes = this.PackMessage(null).ToBytes(); }
/// <summary> /// Variables. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> public static IList <Variable> Variables(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } var code = message.TypeCode(); return(code == SnmpType.Unknown ? new List <Variable>(0) : message.Scope.Pdu.Variables); }
/// <summary> /// Processes the message. /// </summary> /// <param name="message">Message.</param> /// <param name="sender">Sender.</param> /// <param name="binding">The binding.</param> public void Process(ISnmpMessage message, System.Net.IPEndPoint sender, ListenerBinding binding) { if (binding == null) { throw new ArgumentNullException("binding"); } if (message == null) { throw new ArgumentNullException("message"); } if (sender == null) { throw new ArgumentNullException("sender"); } if (message.Version != VersionCode.V3) { return; } switch (message.Pdu.TypeCode) { case SnmpType.TrapV2Pdu: { EventHandler <MessageReceivedEventArgs <TrapV2Message> > handler = TrapV2Received; if (handler != null) { handler(this, new MessageReceivedEventArgs <TrapV2Message>(sender, (TrapV2Message)message, binding)); } break; } case SnmpType.InformRequestPdu: { InformRequestMessage inform = (InformRequestMessage)message; binding.SendResponse(inform.GenerateResponse(), sender); EventHandler <MessageReceivedEventArgs <InformRequestMessage> > handler = InformRequestReceived; if (handler != null) { handler(this, new MessageReceivedEventArgs <InformRequestMessage>(sender, inform, binding)); } break; } default: break; } }
/// <summary> /// Packs up the <see cref="ISnmpMessage"/>. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> /// <returns></returns> internal static Sequence PackMessage(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException("message"); } return(PackMessage(message.Version, message.Header, message.Parameters, message.Privacy.Encrypt(message.Scope.GetData(message.Version), message.Parameters))); }
/// <summary> /// Processes the message. /// </summary> /// <param name="message">Message.</param> /// <param name="sender">Sender.</param> /// <param name="binding">The binding.</param> public void Process(ISnmpMessage message, System.Net.IPEndPoint sender, ListenerBinding binding) { if (binding == null) { throw new ArgumentNullException("binding"); } if (message == null) { throw new ArgumentNullException("message"); } if (sender == null) { throw new ArgumentNullException("sender"); } if (message.Version != VersionCode.V2) { return; } switch (message.Pdu.TypeCode) { case SnmpType.TrapV2Pdu: { EventHandler<MessageReceivedEventArgs<TrapV2Message>> handler = TrapV2Received; if (handler != null) { handler(this, new MessageReceivedEventArgs<TrapV2Message>(sender, (TrapV2Message)message, binding)); } break; } case SnmpType.InformRequestPdu: { InformRequestMessage inform = (InformRequestMessage)message; binding.SendResponse(inform.GenerateResponse(), sender); EventHandler<MessageReceivedEventArgs<InformRequestMessage>> handler = InformRequestReceived; if (handler != null) { handler(this, new MessageReceivedEventArgs<InformRequestMessage>(sender, inform, binding)); } break; } default: break; } }
public void TestResponseVersion3() { var engine = CreateEngine(); engine.Listener.ClearBindings(); var serverEndPoint = new IPEndPoint(IPAddress.Loopback, Port.NextId); engine.Listener.AddBinding(serverEndPoint); engine.Start(); try { IAuthenticationProvider auth = new MD5AuthenticationProvider(new OctetString("authentication")); IPrivacyProvider priv = new DefaultPrivacyProvider(auth); var ending = new AutoResetEvent(false); var timeout = 3000; Discovery discovery = Messenger.GetNextDiscovery(SnmpType.GetRequestPdu); ReportMessage report = discovery.GetResponse(timeout, serverEndPoint); var expected = Messenger.NextRequestId; GetRequestMessage request = new GetRequestMessage(VersionCode.V3, Messenger.NextMessageId, expected, new OctetString("authen"), OctetString.Empty, new List <Variable> { new Variable(new ObjectIdentifier("1.3.6.1.2.1.1.1.0")) }, priv, Messenger.MaxMessageSize, report); var source = Observable.Defer(() => { ISnmpMessage reply = request.GetResponse(timeout, serverEndPoint); return(Observable.Return(reply)); }) .RetryWithBackoffStrategy( retryCount: 4, retryOnError: e => e is Messaging.TimeoutException ); source.Subscribe(reply => { ISnmpPdu snmpPdu = reply.Pdu(); Assert.Equal(SnmpType.ResponsePdu, snmpPdu.TypeCode); Assert.Equal(expected, reply.RequestId()); Assert.Equal(ErrorCode.NoError, snmpPdu.ErrorStatus.ToErrorCode()); ending.Set(); }); Assert.True(ending.WaitOne(MaxTimeout)); } finally { if (SnmpMessageExtension.IsRunningOnWindows) { engine.Stop(); } } }
/// <summary> /// Sends an <see cref="ISnmpMessage"/> and handles the response from agent. /// </summary> /// <param name="request">The <see cref="ISnmpMessage"/>.</param> /// <param name="connectionTimeout">The time-out value, in milliseconds for how long to wait for a connection</param> /// <param name="responseTimeout">The time-out value, in milliseconds for how long to wait for a response. The default value is 0, which indicates an infinite time-out period. Specifying -1 also indicates an infinite time-out period.</param> /// <param name="receiver">Agent.</param> /// <param name="client">The DTLS client</param> /// <param name="registry">The user registry.</param> /// <returns></returns> public static async Task <ISnmpMessage> GetSecureResponseAsync(this ISnmpMessage request, TimeSpan connectionTimeout, TimeSpan responseTimeout, IPEndPoint receiver, Client client, UserRegistry registry) { if (request == null) { throw new ArgumentNullException(nameof(request)); } if (receiver == null) { throw new ArgumentNullException(nameof(receiver)); } if (client is null) { throw new ArgumentNullException(nameof(client)); } if (registry == null) { throw new ArgumentNullException(nameof(registry)); } var requestCode = request.TypeCode(); if (requestCode == SnmpType.TrapV1Pdu || requestCode == SnmpType.TrapV2Pdu || requestCode == SnmpType.ReportPdu) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "not a request message: {0}", requestCode)); } var bytes = request.ToBytes(); await client.ConnectToServerAsync(receiver, responseTimeout, connectionTimeout).ConfigureAwait(false); var reply = await client.SendAndGetResponseAsync(bytes, responseTimeout).ConfigureAwait(false); // Passing 'count' is not necessary because ParseMessages should ignore it, but it offer extra safety (and would avoid an issue if parsing >1 response). var response = MessageFactory.ParseMessages(reply, 0, reply.Length, registry)[0]; var responseCode = response.TypeCode(); if (responseCode == SnmpType.ResponsePdu || responseCode == SnmpType.ReportPdu) { var requestId = request.MessageId(); var responseId = response.MessageId(); if (responseId != requestId) { throw OperationException.Create(string.Format(CultureInfo.InvariantCulture, "wrong response sequence: expected {0}, received {1}", requestId, responseId), receiver.Address); } return(response); } throw OperationException.Create(string.Format(CultureInfo.InvariantCulture, "wrong response type: {0}", responseCode), receiver.Address); }
public void TestToBytes3() { if (!DESPrivacyProvider.IsSupported) { return; } var privacy = new DESPrivacyProvider(new OctetString("privacyphrase"), new MD5AuthenticationProvider(new OctetString("authentication"))); var trap = new TrapV2Message( VersionCode.V3, new Header( new Integer32(1004947569), new Integer32(0x10000), privacy.ToSecurityLevel()), new SecurityParameters( new OctetString(ByteTool.Convert("80001F8880E9630000D61FF449")), Integer32.Zero, Integer32.Zero, new OctetString("lextm"), new OctetString(ByteTool.Convert("61A9A486AF4A861BD5C0BB1F")), new OctetString(ByteTool.Convert("0000000069D39B2A"))), new Scope(OctetString.Empty, OctetString.Empty, new TrapV2Pdu( 234419641, new ObjectIdentifier("1.3.6"), 0, new List <Variable>())), privacy, null); byte[] bytes = trap.ToBytes(); UserRegistry registry = new UserRegistry(); registry.Add(new OctetString("lextm"), privacy); IList <ISnmpMessage> messages = MessageFactory.ParseMessages(bytes, registry); Assert.Equal(1, messages.Count); ISnmpMessage message = messages[0]; Assert.Equal("80001F8880E9630000D61FF449", message.Parameters.EngineId.ToHexString()); Assert.Equal(0, message.Parameters.EngineBoots.ToInt32()); Assert.Equal(0, message.Parameters.EngineTime.ToInt32()); Assert.Equal("lextm", message.Parameters.UserName.ToString()); Assert.Equal("61A9A486AF4A861BD5C0BB1F", message.Parameters.AuthenticationParameters.ToHexString()); Assert.Equal("0000000069D39B2A", message.Parameters.PrivacyParameters.ToHexString()); Assert.Equal("", message.Scope.ContextEngineId.ToHexString()); // SNMP#NET returns string.Empty here. Assert.Equal("", message.Scope.ContextName.ToHexString()); Assert.Equal(0, message.Scope.Pdu.Variables.Count); Assert.Equal(1004947569, message.MessageId()); Assert.Equal(234419641, message.RequestId()); }
/// <summary> /// Gets the handler. /// </summary> /// <param name="message">The message.</param> /// <returns></returns> public IMessageHandler GetHandler(ISnmpMessage message) { foreach (var mapping in _mappings) { if (mapping.CanHandle(message) == false) { continue; } return(mapping.Handler); } return(_nullHandler); }
/// <summary> /// Gets the level. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> /// <value>The level.</value> internal static Levels Level(this ISnmpMessage message) { if (message == null) { throw new ArgumentNullException("message"); } if (message.Version != VersionCode.V3) { throw new ArgumentException("this method only applies to v3 messages", "message"); } return(message.Privacy.ToSecurityLevel()); }
/// <summary> /// Walks. /// </summary> /// <param name="version">Protocol version.</param> /// <param name="endpoint">Endpoint.</param> /// <param name="community">Community name.</param> /// <param name="table">OID.</param> /// <param name="list">A list to hold the results.</param> /// <param name="maxRepetitions">The max repetitions.</param> /// <param name="mode">Walk mode.</param> /// <param name="privacy">The privacy provider.</param> /// <param name="report">The report.</param> /// <returns></returns> public static async Task <int> BulkWalkAsync( VersionCode version, IPEndPoint endpoint, OctetString community, ObjectIdentifier table, IList <Variable> list, int maxRepetitions, WalkMode mode, IPrivacyProvider privacy, ISnmpMessage report) { if (list == null) { throw new ArgumentNullException("list"); } var tableV = new Variable(table); var seed = tableV; IList <Variable> next; var result = 0; var message = report; var data = await BulkHasNextAsync(version, endpoint, community, seed, maxRepetitions, privacy, message).ConfigureAwait(false); next = data.Item2; message = data.Item3; while (data.Item1) { var subTreeMask = string.Format(CultureInfo.InvariantCulture, "{0}.", table); var rowMask = string.Format(CultureInfo.InvariantCulture, "{0}.1.1.", table); foreach (var v in next) { var id = v.Id.ToString(); if (v.Data.TypeCode == SnmpType.EndOfMibView) { goto end; } if (mode == WalkMode.WithinSubtree && !id.StartsWith(subTreeMask, StringComparison.Ordinal)) { // not in sub tree goto end; } list.Add(v); if (id.StartsWith(rowMask, StringComparison.Ordinal)) { result++; } } seed = next[next.Count - 1]; data = await BulkHasNextAsync(version, endpoint, community, seed, maxRepetitions, privacy, message).ConfigureAwait(false); } end: return(result); }
public void TestParseNoVarbind() { byte[] buffer = Properties.Resources.novarbind; ISnmpMessage m = MessageFactory.ParseMessages(buffer, new UserRegistry())[0]; TrapV1Message message = (TrapV1Message)m; Assert.AreEqual(GenericCode.EnterpriseSpecific, message.Generic); Assert.AreEqual(12, message.Specific); Assert.AreEqual("public", message.Community.ToString()); Assert.AreEqual(IPAddress.Parse("127.0.0.1"), message.AgentAddress); Assert.AreEqual(new uint[] { 1, 3 }, message.Enterprise.ToNumerical()); Assert.AreEqual(16352, message.TimeStamp); Assert.AreEqual(0, message.Variables().Count); }
private static bool BulkHasNext( VersionCode version, IPEndPoint receiver, OctetString community, Variable seed, int timeout, int maxRepetitions, out IList <Variable> next, IPrivacyProvider privacy, ref ISnmpMessage report) { if (version == VersionCode.V1) { throw new ArgumentException("v1 is not supported", "version"); } var variables = new List <Variable> { new Variable(seed.Id) }; var request = version == VersionCode.V3 ? new GetBulkRequestMessage(version, MessageCounter.NextId, RequestCounter.NextId, community, 0, maxRepetitions, variables, privacy, MaxMessageSize, report) : new GetBulkRequestMessage(RequestCounter.NextId, version, community, 0, maxRepetitions, variables); var reply = request.GetResponse(timeout, receiver); if (reply is ReportMessage) { if (reply.Pdu().Variables.Count == 0) { // TODO: whether it is good to return? next = new List <Variable> (0); return(false); } var id = reply.Pdu().Variables[0].Id; if (id != IdNotInTimeWindow) { // var error = id.GetErrorMessage(); // TODO: whether it is good to return? next = new List <Variable> (0); return(false); } // according to RFC 3414, send a second request to sync time. request = new GetBulkRequestMessage(version, MessageCounter.NextId, RequestCounter.NextId, community, 0, maxRepetitions, variables, privacy, MaxMessageSize, reply); reply = request.GetResponse(timeout, receiver); } else if (reply.Pdu().ErrorStatus.ToInt32() != 0) { throw ErrorException.Create("error in response", receiver.Address, reply); } next = reply.Pdu().Variables; report = request; return(next.Count != 0); }
private void m_wndListView_SelectedIndexChanged(object sender, EventArgs e) { if (m_wndListView.SelectedItems.Count == 1) { ISnmpMessage message = m_wndListView.SelectedItems[0].Tag as ISnmpMessage; m_wndListeVariables.Items.Clear(); m_properties.SelectedObject = message.Pdu(); foreach (Variable v in message.Variables()) { ListViewItem item = new ListViewItem(v.Id.ToString()); item.SubItems.Add(v.Data.ToString()); m_wndListeVariables.Items.Add(item); } } }
public void Test() { byte[] expected = Properties.Resources.get; ISnmpMessage message = MessageFactory.ParseMessages(expected, new UserRegistry())[0]; Assert.Equal(SnmpType.GetRequestPdu, message.TypeCode()); GetRequestPdu pdu = (GetRequestPdu)message.Pdu(); Assert.Equal(1, pdu.Variables.Count); Variable v = pdu.Variables[0]; Assert.Equal(new uint[] { 1, 3, 6, 1, 2, 1, 1, 6, 0 }, v.Id.ToNumerical()); Assert.Equal(typeof(Null), v.Data.GetType()); Assert.True(expected.Length >= message.ToBytes().Length); }
/// <summary> /// Sends a response message. /// </summary> /// <param name="response"> /// A <see cref="ISnmpMessage"/>. /// </param> /// <param name="receiver">Receiver.</param> public async Task SendResponseAsync(ISnmpMessage response, EndPoint receiver) { if (_disposed) { throw new ObjectDisposedException(GetType().FullName); } if (response == null) { throw new ArgumentNullException(nameof(response)); } if (receiver == null) { throw new ArgumentNullException(nameof(receiver)); } if (_disposed) { throw new ObjectDisposedException("Listener"); } if (_socket == null) { return; } var buffer = response.ToBytes(); var info = SocketExtension.EventArgsFactory.Create(); try { info.RemoteEndPoint = receiver; info.SetBuffer(buffer, 0, buffer.Length); using (var awaitable1 = new SocketAwaitable(info)) { await _socket.SendToAsync(awaitable1); } } catch (SocketException ex) { if (ex.SocketErrorCode != SocketError.Interrupted) { // IMPORTANT: interrupted means the socket is closed. throw; } } }
public void Getv3Async(IPAddress ipAddress, string oid, SNMPv3Security security, string username, SNMPv3AuthenticationProvider authProvider, string auth, SNMPv3PrivacyProvider privProvider, string priv, SNMPOptions options) { Task.Run(() => { try { IPEndPoint ipEndpoint = new IPEndPoint(ipAddress, options.Port); // Discovery Discovery discovery = Messenger.GetNextDiscovery(SnmpType.GetRequestPdu); ReportMessage report = discovery.GetResponse(options.Timeout, ipEndpoint); IPrivacyProvider privacy; if (security == SNMPv3Security.authPriv) { privacy = GetPrivacy(authProvider, auth, privProvider, priv); } else if (security == SNMPv3Security.authNoPriv) { privacy = GetPrivacy(authProvider, auth); } else // noAuthNoPriv { privacy = GetPrivacy(); } GetRequestMessage request = new GetRequestMessage(VersionCode.V3, Messenger.NextMessageId, Messenger.NextRequestId, new OctetString(username), new List <Variable> { new Variable(new ObjectIdentifier(oid)) }, privacy, Messenger.MaxMessageSize, report); ISnmpMessage reply = request.GetResponse(options.Timeout, ipEndpoint); Variable result = reply.Pdu().Variables[0]; OnReceived(new SNMPReceivedArgs(result.Id, result.Data)); OnComplete(); } catch (Lextm.SharpSnmpLib.Messaging.TimeoutException) { OnTimeout(); } catch (ErrorException) { OnError(); } }); }
/// <summary> /// Initializes a new instance of the <see cref="Discovery"/> class. /// </summary> /// <param name="requestId">The request id.</param> /// <param name="messageId">The message id.</param> /// <param name="maxMessageSize">The max size of message.</param> public Discovery(int messageId, int requestId, int maxMessageSize) { _discovery = new GetRequestMessage( VersionCode.V3, new Header( new Integer32(messageId), new Integer32(maxMessageSize), Levels.Reportable), DefaultSecurityParameters, new Scope( OctetString.Empty, OctetString.Empty, new GetRequestPdu(requestId, new List<Variable>())), DefaultPrivacyProvider.DefaultPair, null); }
/// <summary> /// Initializes a new instance of the <see cref="Discovery"/> class. /// </summary> /// <param name="requestId">The request id.</param> /// <param name="messageId">The message id.</param> /// <param name="maxMessageSize">The max size of message.</param> public Discovery(int messageId, int requestId, int maxMessageSize) { _discovery = new GetRequestMessage( VersionCode.V3, new Header( new Integer32(messageId), new Integer32(maxMessageSize), Levels.Reportable), DefaultSecurityParameters, new Scope( OctetString.Empty, OctetString.Empty, new GetRequestPdu(requestId, new List <Variable>())), DefaultPrivacyProvider.DefaultPair, null); }
/// <summary> /// Creates a <see cref="MessageReceivedEventArgs"/>. /// </summary> /// <param name="sender">Sender.</param> /// <param name="message">The message received.</param> /// <param name="binding">The binding.</param> public MessageReceivedEventArgs(IPEndPoint sender, ISnmpMessage message, IListenerBinding binding) { if (sender == null) { throw new ArgumentNullException("sender"); } if (message == null) { throw new ArgumentNullException("message"); } if (binding == null) { throw new ArgumentNullException("binding"); } Sender = sender; Message = message; Binding = binding; }
/// <summary> /// Processes the message. /// </summary> /// <param name="message">Message.</param> /// <param name="sender">Sender.</param> /// <param name="binding">The binding.</param> public void Process(ISnmpMessage message, System.Net.IPEndPoint sender, ListenerBinding binding) { if (message == null) { throw new ArgumentNullException("message"); } if (sender == null) { throw new ArgumentNullException("sender"); } if (binding == null) { throw new ArgumentNullException("binding"); } if (message.Version != VersionCode.V1) { return; } switch (message.Pdu.TypeCode) { case SnmpType.TrapV1Pdu: { EventHandler<MessageReceivedEventArgs<TrapV1Message>> handler = TrapV1Received; if (handler != null) { handler(this, new MessageReceivedEventArgs<TrapV1Message>(sender, (TrapV1Message)message, binding)); } break; } default: break; } }
/// <summary> /// Creates a <see cref="GetBulkRequestMessage"/> with a specific <see cref="Sequence"/>. /// </summary> /// <param name="version">The version.</param> /// <param name="messageId">The message id.</param> /// <param name="requestId">The request id.</param> /// <param name="userName">Name of the user.</param> /// <param name="contextName">Name of context.</param> /// <param name="nonRepeaters">The non repeaters.</param> /// <param name="maxRepetitions">The max repetitions.</param> /// <param name="variables">The variables.</param> /// <param name="privacy">The privacy provider.</param> /// <param name="maxMessageSize">Size of the max message.</param> /// <param name="report">The report.</param> public GetBulkRequestMessage(VersionCode version, int messageId, int requestId, OctetString userName, OctetString contextName, int nonRepeaters, int maxRepetitions, IList<Variable> variables, IPrivacyProvider privacy, int maxMessageSize, ISnmpMessage report) { if (variables == null) { throw new ArgumentNullException("variables"); } if (userName == null) { throw new ArgumentNullException("userName"); } if (contextName == null) { throw new ArgumentNullException("contextName"); } if (version != VersionCode.V3) { throw new ArgumentException("only v3 is supported", "version"); } if (report == null) { throw new ArgumentNullException("report"); } if (privacy == null) { throw new ArgumentNullException("privacy"); } if (nonRepeaters > variables.Count) { throw new ArgumentException("nonRepeaters should not be greater than variable count", "nonRepeaters"); } if (maxRepetitions < 1) { throw new ArgumentException("maxRepetitions should be greater than 0", "maxRepetitions"); } Version = version; Privacy = privacy; // TODO: define more constants. Header = new Header(new Integer32(messageId), new Integer32(maxMessageSize), privacy.ToSecurityLevel() | Levels.Reportable); var parameters = report.Parameters; var authenticationProvider = Privacy.AuthenticationProvider; Parameters = new SecurityParameters( parameters.EngineId, parameters.EngineBoots, parameters.EngineTime, userName, authenticationProvider.CleanDigest, Privacy.Salt); var pdu = new GetBulkRequestPdu( requestId, nonRepeaters, maxRepetitions, variables); var scope = report.Scope; var contextEngineId = scope.ContextEngineId == OctetString.Empty ? parameters.EngineId : scope.ContextEngineId; Scope = new Scope(contextEngineId, contextName, pdu); authenticationProvider.ComputeHash(Version, Header, Parameters, Scope, Privacy); _bytes = this.PackMessage(null).ToBytes(); }
public GetBulkRequestMessage(VersionCode version, int messageId, int requestId, OctetString userName, int nonRepeaters, int maxRepetitions, IList<Variable> variables, IPrivacyProvider privacy, ISnmpMessage report) : this(version, messageId, requestId, userName, nonRepeaters, maxRepetitions, variables, privacy, 0xFFE3, report) { }
/// <summary> /// Sends a response message. /// </summary> /// <param name="response"> /// A <see cref="ISnmpMessage"/>. /// </param> /// <param name="receiver">Receiver.</param> public void SendResponse(ISnmpMessage response, EndPoint receiver) { if (_disposed) { throw new ObjectDisposedException(GetType().FullName); } if (response == null) { throw new ArgumentNullException("response"); } if (receiver == null) { throw new ArgumentNullException("receiver"); } if (_disposed) { throw new ObjectDisposedException("Listener"); } if (_socket == null) { return; } var buffer = response.ToBytes(); _socket.BeginSendTo(buffer, 0, buffer.Length, 0, receiver, ar => _socket.EndSendTo(ar), null); }
/// <summary> /// Initializes a new instance of the <see cref="SetRequestMessage"/> class. /// </summary> /// <param name="version">The version.</param> /// <param name="messageId">The message id.</param> /// <param name="requestId">The request id.</param> /// <param name="userName">Name of the user.</param> /// <param name="variables">The variables.</param> /// <param name="privacy">The privacy provider.</param> /// <param name="maxMessageSize">Size of the max message.</param> /// <param name="report">The report.</param> public SetRequestMessage(VersionCode version, int messageId, int requestId, OctetString userName, IList<Variable> variables, IPrivacyProvider privacy, int maxMessageSize, ISnmpMessage report) { if (variables == null) { throw new ArgumentNullException("variables"); } if (userName == null) { throw new ArgumentNullException("userName"); } if (version != VersionCode.V3) { throw new ArgumentException("only v3 is supported", "version"); } if (report == null) { throw new ArgumentNullException("report"); } if (privacy == null) { throw new ArgumentNullException("privacy"); } Version = version; Privacy = privacy; Levels recordToSecurityLevel = PrivacyProviderExtension.ToSecurityLevel(privacy); recordToSecurityLevel |= Levels.Reportable; byte b = (byte)recordToSecurityLevel; // TODO: define more constants. Header = new Header(new Integer32(messageId), new Integer32(maxMessageSize), new OctetString(new[] { b }), new Integer32(3)); var parameters = report.Parameters; var authenticationProvider = Privacy.AuthenticationProvider; Parameters = new SecurityParameters( parameters.EngineId, parameters.EngineBoots, parameters.EngineTime, userName, authenticationProvider.CleanDigest, Privacy.Salt); SetRequestPdu pdu = new SetRequestPdu( requestId, ErrorCode.NoError, 0, variables); var scope = report.Scope; Scope = new Scope(scope.ContextEngineId, scope.ContextName, pdu); Parameters.AuthenticationParameters = authenticationProvider.ComputeHash(Version, Header, Parameters, Scope, Privacy); _bytes = SnmpMessageExtension.PackMessage(Version, Header, Parameters, Scope, Privacy).ToBytes(); }
public InformRequestMessage(VersionCode version, int messageId, int requestId, OctetString userName, ObjectIdentifier enterprise, uint time, IList<Variable> variables, IPrivacyProvider privacy, ISnmpMessage report) : this(version, messageId, requestId, userName, enterprise, time, variables, privacy, 0xFFE3, report) { }
public static void SendInform(int requestId, VersionCode version, IPEndPoint receiver, OctetString community, ObjectIdentifier enterprise, uint timestamp, IList<Variable> variables, int timeout, IPrivacyProvider privacy, ISnmpMessage report) { if (receiver == null) { throw new ArgumentNullException("receiver"); } if (community == null) { throw new ArgumentNullException("community"); } if (enterprise == null) { throw new ArgumentNullException("enterprise"); } if (variables == null) { throw new ArgumentNullException("variables"); } if (version == VersionCode.V3 && privacy == null) { throw new ArgumentNullException("privacy"); } if (version == VersionCode.V3 && report == null) { throw new ArgumentNullException("report"); } var message = version == VersionCode.V3 ? new InformRequestMessage( version, MessageCounter.NextId, requestId, community, enterprise, timestamp, variables, privacy, MaxMessageSize, report) : new InformRequestMessage( requestId, version, community, enterprise, timestamp, variables); var response = message.GetResponse(timeout, receiver); if (response.Pdu().ErrorStatus.ToInt32() != 0) { throw ErrorException.Create( "error in response", receiver.Address, response); } }
/// <summary> /// Sends a response message. /// </summary> /// <param name="response"> /// A <see cref="ISnmpMessage"/>. /// </param> /// <param name="receiver">Receiver.</param> public void SendResponse(ISnmpMessage response, EndPoint receiver) { if (_disposed) { throw new ObjectDisposedException(GetType().FullName); } if (response == null) { throw new ArgumentNullException("response"); } if (receiver == null) { throw new ArgumentNullException("receiver"); } if (_disposed) { throw new ObjectDisposedException("Listener"); } if (_socket == null) { return; } var buffer = response.ToBytes(); try { _socket.SendTo(buffer, 0, buffer.Length, 0, receiver); } catch (SocketException ex) { if (ex.SocketErrorCode != SocketError.Interrupted) { // IMPORTANT: interrupted means the socket is closed. throw; } } }
private static bool BulkHasNext(VersionCode version, IPEndPoint endpoint, OctetString community, Variable seed, int timeout, int maxRepetitions, out IList<Variable> next, IPrivacyProvider privacy, ref ISnmpMessage report) { if (version == VersionCode.V1) { throw new ArgumentException("v1 is not supported", "version"); } var variables = new List<Variable> { new Variable(seed.Id) }; var requestId = RequestCounter.NextId; var message = version == VersionCode.V3 ? new GetBulkRequestMessage( version, MessageCounter.NextId, requestId, community, 0, maxRepetitions, variables, privacy, MaxMessageSize, report) : new GetBulkRequestMessage( requestId, version, community, 0, maxRepetitions, variables); var response = message.GetResponse(timeout, endpoint); var pdu = response.Pdu(); if (pdu.ErrorStatus.ToInt32() != 0) { throw ErrorException.Create( "error in response", endpoint.Address, response); } next = pdu.Variables; report = message; return next.Count != 0; }
private bool CommandMatched(ISnmpMessage message) { var codeString = message.Pdu.TypeCode.ToString(); return StringEquals(_command, "*") || StringEquals(_command + "RequestPdu", codeString) || StringEquals(_command + "Pdu", codeString); }
/// <summary> /// Creates a <see cref="MessageReceivedEventArgs"/>. /// </summary> /// <param name="sender">Sender.</param> /// <param name="message">The message received.</param> /// <param name="binding">The binding.</param> public MessageReceivedEventArgs(IPEndPoint sender, ISnmpMessage message, IListenerBinding binding) { Sender = sender; Message = message; Binding = binding; }
private bool VersionMatched(ISnmpMessage message) { return _catchAll || _version.Any(v => StringEquals(message.Version.ToString(), v)); }
/// <summary> /// Initializes a new instance of the <see cref="SecureSnmpContext"/> class. /// </summary> /// <param name="request">The request.</param> /// <param name="sender">The sender.</param> /// <param name="users">The users.</param> /// <param name="group">The engine core group.</param> /// <param name="binding">The binding.</param> public SecureSnmpContext(ISnmpMessage request, IPEndPoint sender, UserRegistry users, EngineGroup group, IListenerBinding binding) : base(request, sender, users, group, binding) { }
/// <summary> /// Initializes a new instance of the <see cref="Discovery"/> class. /// </summary> /// <param name="requestId">The request id.</param> /// <param name="messageId">The message id.</param> /// <param name="maxMessageSize">The max size of message.</param> /// <param name="type">Message type.</param> public Discovery(int messageId, int requestId, int maxMessageSize, SnmpType type) { switch (type) { case SnmpType.GetRequestPdu: { _discovery = new GetRequestMessage( VersionCode.V3, new Header( new Integer32(messageId), new Integer32(maxMessageSize), Levels.Reportable), DefaultSecurityParameters, new Scope( OctetString.Empty, OctetString.Empty, new GetRequestPdu(requestId, new List<Variable>())), DefaultPrivacyProvider.DefaultPair, null); break; } case SnmpType.GetNextRequestPdu: { _discovery = new GetNextRequestMessage( VersionCode.V3, new Header( new Integer32(messageId), new Integer32(maxMessageSize), Levels.Reportable), DefaultSecurityParameters, new Scope( OctetString.Empty, OctetString.Empty, new GetNextRequestPdu(requestId, new List<Variable>())), DefaultPrivacyProvider.DefaultPair, null); break; } case SnmpType.GetBulkRequestPdu: { _discovery = new GetBulkRequestMessage( VersionCode.V3, new Header( new Integer32(messageId), new Integer32(maxMessageSize), Levels.Reportable), DefaultSecurityParameters, new Scope( OctetString.Empty, OctetString.Empty, new GetBulkRequestPdu(requestId, 0, 0, new List<Variable>())), DefaultPrivacyProvider.DefaultPair, null); break; } case SnmpType.SetRequestPdu: { _discovery = new SetRequestMessage( VersionCode.V3, new Header( new Integer32(messageId), new Integer32(maxMessageSize), Levels.Reportable), DefaultSecurityParameters, new Scope( OctetString.Empty, OctetString.Empty, new SetRequestPdu(requestId, new List<Variable>())), DefaultPrivacyProvider.DefaultPair, null); break; } case SnmpType.InformRequestPdu: { _discovery = new InformRequestMessage( VersionCode.V3, new Header( new Integer32(messageId), new Integer32(maxMessageSize), Levels.Reportable), DefaultSecurityParameters, new Scope( OctetString.Empty, OctetString.Empty, new InformRequestPdu(requestId)), DefaultPrivacyProvider.DefaultPair, null); break; } default: throw new ArgumentException("discovery message must be a request", "type"); } }
/// <summary> /// Creates a <see cref="ErrorException"/>. /// </summary> /// <param name="message">Message.</param> /// <param name="agent">Agent address.</param> /// <param name="body">Error message body.</param> /// <returns></returns> public static ErrorException Create(string message, IPAddress agent, ISnmpMessage body) { var ex = new ErrorException(message) { Agent = agent, Body = body }; return ex; }
/// <summary> /// Initializes a new instance of the <see cref="NormalSnmpContext"/> class. /// </summary> /// <param name="request">The request.</param> /// <param name="sender">The sender.</param> /// <param name="users">The users.</param> /// <param name="binding">The binding.</param> public NormalSnmpContext(ISnmpMessage request, IPEndPoint sender, UserRegistry users, IListenerBinding binding) : base(request, sender, users, null, binding) { }
/// <summary> /// Initializes a new instance of the <see cref="SetRequestMessage"/> class. /// </summary> /// <param name="version">The version.</param> /// <param name="messageId">The message id.</param> /// <param name="requestId">The request id.</param> /// <param name="userName">Name of the user.</param> /// <param name="variables">The variables.</param> /// <param name="privacy">The privacy provider.</param> /// <param name="maxMessageSize">Size of the max message.</param> /// <param name="report">The report.</param> public SetRequestMessage(VersionCode version, int messageId, int requestId, OctetString userName, IList<Variable> variables, IPrivacyProvider privacy, int maxMessageSize, ISnmpMessage report) { if (variables == null) { throw new ArgumentNullException("variables"); } if (userName == null) { throw new ArgumentNullException("userName"); } if (version != VersionCode.V3) { throw new ArgumentException("only v3 is supported", "version"); } if (report == null) { throw new ArgumentNullException("report"); } if (privacy == null) { throw new ArgumentNullException("privacy"); } Version = version; Privacy = privacy; Header = new Header(new Integer32(messageId), new Integer32(maxMessageSize), privacy.ToSecurityLevel() | Levels.Reportable); var parameters = report.Parameters; var authenticationProvider = Privacy.AuthenticationProvider; Parameters = new SecurityParameters( parameters.EngineId, parameters.EngineBoots, parameters.EngineTime, userName, authenticationProvider.CleanDigest, Privacy.Salt); var pdu = new SetRequestPdu( requestId, variables); var scope = report.Scope; var contextEngineId = scope.ContextEngineId == OctetString.Empty ? parameters.EngineId : scope.ContextEngineId; Scope = new Scope(contextEngineId, scope.ContextName, pdu); authenticationProvider.ComputeHash(Version, Header, Parameters, Scope, Privacy); _bytes = this.PackMessage(null).ToBytes(); }
public SetRequestMessage(VersionCode version, int messageId, int requestId, OctetString userName, IList<Variable> variables, IPrivacyProvider privacy, ISnmpMessage report) : this(version, messageId, requestId, userName, variables, privacy, 0xFFE3, report) { }
/// <summary> /// Walks. /// </summary> /// <param name="version">Protocol version.</param> /// <param name="endpoint">Endpoint.</param> /// <param name="community">Community name.</param> /// <param name="table">OID.</param> /// <param name="list">A list to hold the results.</param> /// <param name="timeout">The time-out value, in milliseconds. The default value is 0, which indicates an infinite time-out period. Specifying -1 also indicates an infinite time-out period.</param> /// <param name="maxRepetitions">The max repetitions.</param> /// <param name="mode">Walk mode.</param> /// <param name="privacy">The privacy provider.</param> /// <param name="report">The report.</param> /// <returns></returns> public static int BulkWalk(VersionCode version, IPEndPoint endpoint, OctetString community, ObjectIdentifier table, IList<Variable> list, int timeout, int maxRepetitions, WalkMode mode, IPrivacyProvider privacy, ISnmpMessage report) { if (list == null) { throw new ArgumentNullException("list"); } var tableV = new Variable(table); var seed = tableV; IList<Variable> next; var result = 0; var message = report; while (BulkHasNext(version, endpoint, community, seed, timeout, maxRepetitions, out next, privacy, ref message)) { var subTreeMask = string.Format(CultureInfo.InvariantCulture, "{0}.", table); var rowMask = string.Format(CultureInfo.InvariantCulture, "{0}.1.1.", table); foreach (var v in next) { var id = v.Id.ToString(); if (v.Data.TypeCode == SnmpType.EndOfMibView) { goto end; } if (mode == WalkMode.WithinSubtree && !id.StartsWith(subTreeMask, StringComparison.Ordinal)) { // not in sub tree goto end; } list.Add(v); if (id.StartsWith(rowMask, StringComparison.Ordinal)) { result++; } } seed = next[next.Count - 1]; } end: return result; }
/// <summary> /// Sends a response message. /// </summary> /// <param name="response"> /// A <see cref="ISnmpMessage"/>. /// </param> /// <param name="receiver">Receiver.</param> public void SendResponse(ISnmpMessage response, EndPoint receiver) { if (_disposed) { throw new ObjectDisposedException(GetType().FullName); } if (response == null) { throw new ArgumentNullException("response"); } if (receiver == null) { throw new ArgumentNullException("receiver"); } if (_disposed) { throw new ObjectDisposedException("Listener"); } if (_socket == null) { return; } byte[] buffer = response.ToBytes(); # if ! SILVERLIGHT // mc++ _socket.BeginSendTo(buffer, 0, buffer.Length, 0, receiver, null, null); # endif }
private static bool BulkHasNext(VersionCode version, IPEndPoint receiver, OctetString community, Variable seed, int timeout, int maxRepetitions, out IList<Variable> next, IPrivacyProvider privacy, ref ISnmpMessage report) { if (version == VersionCode.V1) { throw new ArgumentException("v1 is not supported", "version"); } var variables = new List<Variable> { new Variable(seed.Id) }; var request = version == VersionCode.V3 ? new GetBulkRequestMessage( version, MessageCounter.NextId, RequestCounter.NextId, community, 0, maxRepetitions, variables, privacy, MaxMessageSize, report) : new GetBulkRequestMessage( RequestCounter.NextId, version, community, 0, maxRepetitions, variables); var reply = request.GetResponse(timeout, receiver); if (reply is ReportMessage) { if (reply.Pdu().Variables.Count == 0) { // TODO: whether it is good to return? next = new List<Variable>(0); return false; } var id = reply.Pdu().Variables[0].Id; if (id != IdNotInTimeWindow) { // var error = id.GetErrorMessage(); // TODO: whether it is good to return? next = new List<Variable>(0); return false; } // according to RFC 3414, send a second request to sync time. request = new GetBulkRequestMessage( version, MessageCounter.NextId, RequestCounter.NextId, community, 0, maxRepetitions, variables, privacy, MaxMessageSize, reply); reply = request.GetResponse(timeout, receiver); } else if (reply.Pdu().ErrorStatus.ToInt32() != 0) { throw ErrorException.Create( "error in response", receiver.Address, reply); } next = reply.Pdu().Variables; report = request; return next.Count != 0; }
/// <summary> /// Determines whether this instance can handle the specified message. /// </summary> /// <param name="message">The message.</param> /// <returns> /// <c>true</c> if this instance can handle the specified message; otherwise, <c>false</c>. /// </returns> public bool CanHandle(ISnmpMessage message) { return VersionMatched(message) && CommandMatched(message); }