/// <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>
/// 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>
/// 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);
}
