/// <summary>
/// Gets a list of variable binds.
/// </summary>
/// <param name="version">Protocol version.</param>
/// <param name="endpoint">Endpoint.</param>
/// <param name="community">Community name.</param>
/// <param name="variables">Variable binds.</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>
/// <returns></returns>
public static IList <Variable> Get(VersionCode version, IPEndPoint endpoint, OctetString community, IList <Variable> variables, int timeout)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
if (community == null)
{
throw new ArgumentNullException("community");
}
if (variables == null)
{
throw new ArgumentNullException("variables");
}
if (version == VersionCode.V3)
{
throw new NotSupportedException("SNMP v3 is not supported");
}
var message = new GetRequestMessage(RequestCounter.NextId, version, community, 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);
}
return(pdu.Variables);
}
/// <summary>
/// Gets the response.
/// </summary>
/// <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">The receiver.</param>
/// <returns></returns>
public ReportMessage GetResponse(int timeout, IPEndPoint receiver)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
using (var socket = receiver.GetSocket())
{
return((ReportMessage)_discovery.GetResponse(timeout, receiver, Empty, socket));
}
}
/// <summary>
/// Gets a list of variable binds.
/// </summary>
/// <param name="version">Protocol version.</param>
/// <param name="endpoint">Endpoint.</param>
/// <param name="community">Community name.</param>
/// <param name="variables">Variable binds.</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>
/// <returns></returns>
public static IList<Variable> Get(VersionCode version, IPEndPoint endpoint, OctetString community, IList<Variable> variables, int timeout)
{
if (version == VersionCode.V3)
{
throw new NotSupportedException("SNMP v3 is not supported");
}
GetRequestMessage message = new GetRequestMessage(RequestCounter.NextId, version, community, variables);
ISnmpMessage response = message.GetResponse(timeout, endpoint);
var pdu = response.Pdu;
if (pdu.ErrorStatus.ToInt32() != 0)
{
throw ErrorException.Create(
"error in response",
endpoint.Address,
response);
}
return pdu.Variables;
}
internal override void Get(Variable variable)
{
if (string.IsNullOrEmpty(UserName))
{
Logger.Info("User name need to be specified for v3.");
return;
}
Discovery discovery = Messenger.NextDiscovery;
ReportMessage report = discovery.GetResponse(Timeout, Agent);
GetRequestMessage request = new GetRequestMessage(VersionCode.V3, Messenger.NextMessageId, Messenger.NextRequestId, new OctetString(UserName), new List<Variable> { variable }, _privacy, Messenger.MaxMessageSize, report);
ISnmpMessage response = request.GetResponse(Timeout, Agent);
if (response.Pdu.ErrorStatus.ToInt32() != 0)
{
throw ErrorException.Create(
"error in response",
Agent.Address,
response);
}
Logger.Info(response.Pdu.Variables[0].ToString(Objects));
}
public static void Main(string[] args)
{
string community = "public";
bool showHelp = false;
bool showVersion = false;
VersionCode version = VersionCode.V1;
int timeout = 1000;
int retry = 0;
Levels level = Levels.Reportable;
string user = string.Empty;
string authentication = string.Empty;
string authPhrase = string.Empty;
string privacy = string.Empty;
string privPhrase = string.Empty;
bool dump = false;
OptionSet p = new OptionSet()
.Add("c:", "-c for community name, (default is public)", delegate (string v) { if (v != null) community = v; })
.Add("l:", "-l for security level, (default is noAuthNoPriv)", delegate (string v)
{
if (v.ToUpperInvariant() == "NOAUTHNOPRIV")
{
level = Levels.Reportable;
}
else if (v.ToUpperInvariant() == "AUTHNOPRIV")
{
level = Levels.Authentication | Levels.Reportable;
}
else if (v.ToUpperInvariant() == "AUTHPRIV")
{
level = Levels.Authentication | Levels.Privacy | Levels.Reportable;
}
else
{
throw new ArgumentException("no such security mode: " + v);
}
})
.Add("a:", "-a for authentication method (MD5 or SHA)", delegate (string v) { authentication = v; })
.Add("A:", "-A for authentication passphrase", delegate(string v) { authPhrase = v; })
.Add("x:", "-x for privacy method", delegate (string v) { privacy = v; })
.Add("X:", "-X for privacy passphrase", delegate (string v) { privPhrase = v; })
.Add("u:", "-u for security name", delegate(string v) { user = v; })
.Add("h|?|help", "-h, -?, -help for help.", delegate (string v) { showHelp = v != null; })
.Add("V", "-V to display version number of this application.", delegate (string v) { showVersion = v != null; })
.Add("d", "-d to display message dump", delegate(string v) { dump = true; })
.Add("t:", "-t for timeout value (unit is second).", delegate (string v) { timeout = int.Parse(v) * 1000; })
.Add("r:", "-r for retry count (default is 0)", delegate (string v) { retry = int.Parse(v); })
.Add("v|version:", "-v for SNMP version (1, 2, and 3 are currently supported)", delegate (string v)
{
switch (int.Parse(v))
{
case 1:
version = VersionCode.V1;
break;
case 2:
version = VersionCode.V2;
break;
case 3:
version = VersionCode.V3;
break;
default:
throw new ArgumentException("no such version: " + v);
}
});
List<string> extra = p.Parse (args);
if (showHelp)
{
ShowHelp();
return;
}
if (showVersion)
{
Console.WriteLine(System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
return;
}
if (extra.Count < 2)
{
ShowHelp();
return;
}
IPAddress ip;
bool parsed = IPAddress.TryParse(extra[0], out ip);
if (!parsed)
{
foreach (IPAddress address in Dns.GetHostAddresses(extra[0]))
{
if (address.AddressFamily != AddressFamily.InterNetwork)
{
continue;
}
ip = address;
break;
}
if (ip == null)
{
Console.WriteLine("invalid host or wrong IP address found: " + extra[0]);
return;
}
}
try
{
List<Variable> vList = new List<Variable>();
for (int i = 1; i < extra.Count; i++)
{
Variable test = new Variable(new ObjectIdentifier(extra[i]));
vList.Add(test);
}
IPEndPoint receiver = new IPEndPoint(ip, 161);
if (version != VersionCode.V3)
{
foreach (
Variable variable in
Messenger.Get(version, receiver, new OctetString(community), vList, timeout))
{
Console.WriteLine(variable);
}
return;
}
if (string.IsNullOrEmpty(user))
{
Console.WriteLine("User name need to be specified for v3.");
return;
}
IAuthenticationProvider auth = (level & Levels.Authentication) == Levels.Authentication
? GetAuthenticationProviderByName(authentication, authPhrase)
: DefaultAuthenticationProvider.Instance;
IPrivacyProvider priv;
if ((level & Levels.Privacy) == Levels.Privacy)
{
priv = new DESPrivacyProvider(new OctetString(privPhrase), auth);
}
else
{
priv = new DefaultPrivacyProvider(auth);
}
Discovery discovery = Messenger.NextDiscovery;
ReportMessage report = discovery.GetResponse(timeout, receiver);
GetRequestMessage request = new GetRequestMessage(VersionCode.V3, Messenger.NextMessageId, Messenger.NextRequestId, new OctetString(user), vList, priv, Messenger.MaxMessageSize, report);
ISnmpMessage response = request.GetResponse(timeout, receiver);
if (dump)
{
Console.WriteLine(ByteTool.Convert(request.ToBytes()));
}
if (response.Pdu.ErrorStatus.ToInt32() != 0) // != ErrorCode.NoError
{
throw ErrorException.Create(
"error in response",
receiver.Address,
response);
}
foreach (Variable v in response.Pdu.Variables)
{
Console.WriteLine(v);
}
}
catch (SnmpException ex)
{
Console.WriteLine(ex);
}
catch (SocketException ex)
{
Console.WriteLine(ex);
}
}
internal override string GetValue(Variable variable)
{
Discovery discovery = Messenger.NextDiscovery;
ReportMessage report = discovery.GetResponse(Timeout, Agent);
GetRequestMessage request = new GetRequestMessage(VersionCode.V3, Messenger.NextMessageId, Messenger.NextRequestId, new OctetString(UserName), new List<Variable> { variable }, _privacy, Messenger.MaxMessageSize, report);
ISnmpMessage response = request.GetResponse(Timeout, Agent);
if (response.Pdu.ErrorStatus.ToInt32() != 0)
{
throw ErrorException.Create(
"error in response",
Agent.Address,
response);
}
return response.Pdu.Variables[0].Data.ToString();
}
public void TestTimeOut()
{
// IMPORTANT: this test case requires a local SNMP agent such as
// #SNMP Agent (snmpd),
// Windows SNMP agent service,
// Net-SNMP agent, or
// snmp4j agent.
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
GetRequestMessage message = new GetRequestMessage(0x4bed, VersionCode.V2, new OctetString("public"), new List<Variable> { new Variable(new ObjectIdentifier("1.3.6.1.2.1.1.1.0")) });
const int time = 1500;
bool hasException = false;
try
{
message.GetResponse(time, new IPEndPoint(IPAddress.Loopback, 161), socket);
}
catch (TimeoutException)
{
hasException = true;
}
Assert.IsFalse(hasException);
System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
try
{
timer.Start();
//IMPORTANT: test against an agent that doesn't exist.
// ReSharper disable AssignNullToNotNullAttribute
message.GetResponse(time, new IPEndPoint(IPAddress.Parse("192.168.0.233"), 161), socket);
// ReSharper restore AssignNullToNotNullAttribute
}
catch (TimeoutException)
{
hasException = true;
}
catch (SocketException)
{
hasException = true;
}
timer.Stop();
long elapsedMilliseconds = timer.ElapsedMilliseconds;
Console.WriteLine(@"elapsed: " + elapsedMilliseconds);
Console.WriteLine(@"timeout: " + time);
Assert.LessOrEqual(time, elapsedMilliseconds);
Assert.IsTrue(hasException);
// FIXME: these values are valid on my machine openSUSE 11.2. (lex)
// This test case usually fails on Windows, as strangely WinSock API call adds an extra 500-ms.
if (SnmpMessageExtension.IsRunningOnMono)
{
Assert.LessOrEqual(elapsedMilliseconds, time + 100);
}
}