public void Discover(VersionCode version, IPEndPoint broadcastAddress, OctetString community, int interval) { if (broadcastAddress == null) { throw new ArgumentNullException("broadcastAddress"); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException("community"); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported", "broadcastAddress"); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); var discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { var message = new GetRequestMessage(_requestId, version, community, _defaultVariables); bytes = message.ToBytes(); } using (var udp = new UdpClient(addressFamily)) { #if (!CF) udp.EnableBroadcast = true; #endif udp.Send(bytes, bytes.Length, broadcastAddress); var activeBefore = Interlocked.CompareExchange(ref _active, Active, Inactive); if (activeBefore == Active) { // If already started, we've nothing to do. return; } _bufferSize = udp.Client.ReceiveBufferSize = Messenger.MaxMessageSize; #if ASYNC Task.Factory.StartNew(() => AsyncBeginReceive(udp.Client)); #else Task.Factory.StartNew(() => AsyncReceive(udp.Client)); #endif Thread.Sleep(interval); Interlocked.CompareExchange(ref _active, Inactive, Active); udp.Close(); } }
/// <summary> /// Discovers agents of the specified version in a specific time interval. /// </summary> /// <param name="version">The version.</param> /// <param name="broadcastAddress">The broadcast address.</param> /// <param name="community">The community.</param> /// <param name="interval">The discovering time interval, in milliseconds.</param> /// <remarks><paramref name="broadcastAddress"/> must be an IPv4 address. IPv6 is not yet supported here.</remarks> public async Task DiscoverAsync(VersionCode version, IPEndPoint broadcastAddress, OctetString community, int interval) { if (broadcastAddress == null) { throw new ArgumentNullException("broadcastAddress"); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException("community"); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported", "broadcastAddress"); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); var discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { var message = new GetRequestMessage(_requestId, version, community, _defaultVariables); bytes = message.ToBytes(); } using (var udp = new Socket(addressFamily, SocketType.Dgram, ProtocolType.Udp)) { var info = SocketExtension.EventArgsFactory.Create(); info.RemoteEndPoint = broadcastAddress; info.SetBuffer(bytes, 0, bytes.Length); using (var awaitable1 = new SocketAwaitable(info)) { await udp.SendToAsync(awaitable1); } var activeBefore = Interlocked.CompareExchange(ref _active, Active, Inactive); if (activeBefore == Active) { // If already started, we've nothing to do. return; } _bufferSize = udp.ReceiveBufferSize; await ReceiveAsync(udp).ConfigureAwait(false); await Task.Delay(interval).ConfigureAwait(false); Interlocked.CompareExchange(ref _active, Inactive, Active); udp.Shutdown(SocketShutdown.Both); } }
/// <summary> /// Discovers agents of the specified version in a specific time interval. /// </summary> /// <param name="version">The version.</param> /// <param name="broadcastAddress">The broadcast address.</param> /// <param name="community">The community.</param> /// <param name="token">The cancellation token.</param> /// <remarks><paramref name="broadcastAddress"/> must be an IPv4 address. IPv6 is not yet supported here.</remarks> public void Discover(VersionCode version, IPEndPoint broadcastAddress, OctetString?community, CancellationToken token) { if (broadcastAddress == null) { throw new ArgumentNullException(nameof(broadcastAddress)); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException(nameof(community)); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported.", nameof(broadcastAddress)); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); var discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { var message = new GetRequestMessage(_requestId, version, community !, _defaultVariables); bytes = message.ToBytes(); } using var udp = new UdpClient(addressFamily); udp.EnableBroadcast = true; AsyncHelper.RunSync(async() => { return(await udp.SendAsync(bytes, broadcastAddress, token)); }); var activeBefore = Interlocked.CompareExchange(ref _active, Active, Inactive); if (activeBefore == Active) { // If already started, we've nothing to do. return; } _bufferSize = udp.Client.ReceiveBufferSize = Messenger.MaxMessageSize; #if ASYNC Task.Factory.StartNew(() => AsyncBeginReceive(udp.Client, token)); #else Task.Factory.StartNew(() => AsyncReceive(udp.Client), token); #endif token.WaitHandle.WaitOne(); Interlocked.CompareExchange(ref _active, Inactive, Active); }
/// <summary> /// Discovers the specified version. /// </summary> /// <param name="version">The version.</param> /// <param name="broadcastAddress">The broadcast address.</param> /// <param name="community">The community.</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> /// <remarks><paramref name="broadcastAddress"/> must be an IPv4 address. IPv6 is not yet supported here.</remarks> public void Discover(VersionCode version, IPEndPoint broadcastAddress, OctetString community, int timeout) { if (broadcastAddress == null) { throw new ArgumentNullException("broadcastAddress"); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException("community"); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported", "broadcastAddress"); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); Discovery discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { Variable v = new Variable(new ObjectIdentifier(new uint[] { 1, 3, 6, 1, 2, 1, 1, 1, 0 })); List <Variable> variables = new List <Variable> { v }; GetRequestMessage message = new GetRequestMessage(_requestId, version, community, variables); bytes = message.ToBytes(); } # if !SILVERLIGHT // mc++ using (UdpClient udp = new UdpClient(addressFamily))
/// <summary> /// Discovers agents of the specified version in a specific time interval. /// </summary> /// <param name="version">The version.</param> /// <param name="broadcastAddress">The broadcast address.</param> /// <param name="community">The community.</param> /// <param name="interval">The discovering time interval, in milliseconds.</param> /// <remarks><paramref name="broadcastAddress"/> must be an IPv4 address. IPv6 is not yet supported here.</remarks> public void Discover(VersionCode version, IPEndPoint broadcastAddress, OctetString community, int interval) { if (broadcastAddress == null) { throw new ArgumentNullException("broadcastAddress"); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException("community"); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported", "broadcastAddress"); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); var discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { var message = new GetRequestMessage(_requestId, version, community, _defaultVariables); bytes = message.ToBytes(); } using (var udp = new UdpClient(addressFamily)) { #if (!CF) udp.EnableBroadcast = true; #endif udp.Send(bytes, bytes.Length, broadcastAddress); var activeBefore = Interlocked.CompareExchange(ref _active, Active, Inactive); if (activeBefore == Active) { // If already started, we've nothing to do. return; } #if CF _bufferSize = 8192; #else _bufferSize = udp.Client.ReceiveBufferSize; #endif #if ASYNC ThreadPool.QueueUserWorkItem(AsyncBeginReceive); #else ThreadPool.QueueUserWorkItem(AsyncReceive, udp.Client); #endif Thread.Sleep(interval); Interlocked.CompareExchange(ref _active, Inactive, Active); udp.Close(); } }
/// <summary> /// Discovers agents of the specified version in a specific time interval. /// </summary> /// <param name="version">The version.</param> /// <param name="broadcastAddress">The broadcast address.</param> /// <param name="community">The community.</param> /// <param name="interval">The discovering time interval, in milliseconds.</param> /// <remarks><paramref name="broadcastAddress"/> must be an IPv4 address. IPv6 is not yet supported here.</remarks> public async Task DiscoverAsync(VersionCode version, IPEndPoint broadcastAddress, OctetString community, int interval) { if (broadcastAddress == null) { throw new ArgumentNullException(nameof(broadcastAddress)); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException(nameof(community)); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported.", nameof(broadcastAddress)); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); var discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { var message = new GetRequestMessage(_requestId, version, community, _defaultVariables); bytes = message.ToBytes(); } using (var udp = new Socket(addressFamily, SocketType.Dgram, ProtocolType.Udp)) { udp.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true); udp.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.PacketInformation, true); var info = SocketExtension.EventArgsFactory.Create(); info.RemoteEndPoint = broadcastAddress; info.SetBuffer(bytes, 0, bytes.Length); using (var awaitable1 = new SocketAwaitable(info)) { await udp.SendToAsync(awaitable1); } var activeBefore = Interlocked.CompareExchange(ref _active, Active, Inactive); if (activeBefore == Active) { // If already started, we've nothing to do. return; } _bufferSize = udp.ReceiveBufferSize; await Task.WhenAny( ReceiveAsync(udp), Task.Delay(interval)); Interlocked.CompareExchange(ref _active, Inactive, Active); try { udp.Shutdown(SocketShutdown.Both); } catch (SocketException ex) { // This exception is thrown in .NET Core <=2.1.4 on non-Windows systems. // However, the shutdown call is necessary to release the socket binding. if (!SnmpMessageExtension.IsRunningOnWindows && ex.SocketErrorCode == SocketError.NotConnected) { } } } }
/// <summary> /// Discovers the specified version. /// </summary> /// <param name="version">The version.</param> /// <param name="broadcastAddress">The broadcast address.</param> /// <param name="community">The community.</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> /// <remarks><paramref name="broadcastAddress"/> must be an IPv4 address. IPv6 is not yet supported here.</remarks> public void Discover(VersionCode version, IPEndPoint broadcastAddress, OctetString community, int timeout) { if (broadcastAddress == null) { throw new ArgumentNullException("broadcastAddress"); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException("community"); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported", "broadcastAddress"); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); Discovery discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { Variable v = new Variable(new ObjectIdentifier(new uint[] { 1, 3, 6, 1, 2, 1, 1, 1, 0 })); List<Variable> variables = new List<Variable> { v }; GetRequestMessage message = new GetRequestMessage(_requestId, version, community, variables); bytes = message.ToBytes(); } # if ! SILVERLIGHT // mc++ using (UdpClient udp = new UdpClient(addressFamily)) { #if (!CF) udp.EnableBroadcast = true; #endif udp.Send(bytes, bytes.Length, broadcastAddress); long activeBefore = Interlocked.CompareExchange(ref _active, 1, 0); if (activeBefore == 1) { // If already started, we've nothing to do. return; } #if CF _bufferSize = 8192; #else _bufferSize = udp.Client.ReceiveBufferSize; #endif #if ASYNC ThreadPool.QueueUserWorkItem(AsyncBeginReceive); #else ThreadPool.QueueUserWorkItem(AsyncReceive, udp.Client); #endif Thread.Sleep(timeout); Interlocked.CompareExchange(ref _active, 0, 1); udp.Close(); } # endif return; }
/// <summary> /// Discovers agents of the specified version in a specific time interval. /// </summary> /// <param name="version">The version.</param> /// <param name="broadcastAddress">The broadcast address.</param> /// <param name="community">The community.</param> /// <param name="interval">The discovering time interval, in milliseconds.</param> /// <remarks><paramref name="broadcastAddress"/> must be an IPv4 address. IPv6 is not yet supported here.</remarks> public void Discover(VersionCode version, IPEndPoint broadcastAddress, OctetString community, int interval) { if (broadcastAddress == null) { throw new ArgumentNullException("broadcastAddress"); } if (version != VersionCode.V3 && community == null) { throw new ArgumentNullException("community"); } var addressFamily = broadcastAddress.AddressFamily; if (addressFamily == AddressFamily.InterNetworkV6) { throw new ArgumentException("IP v6 is not yet supported", "broadcastAddress"); } byte[] bytes; _requestId = Messenger.NextRequestId; if (version == VersionCode.V3) { // throw new NotSupportedException("SNMP v3 is not supported"); var discovery = new Discovery(Messenger.NextMessageId, _requestId, Messenger.MaxMessageSize); bytes = discovery.ToBytes(); } else { var message = new GetRequestMessage(_requestId, version, community, _defaultVariables); bytes = message.ToBytes(); } #if SSHARP using (var udp = new UdpClient()) #else using (var udp = new UdpClient(addressFamily)) #endif { #if !CF && !NETCF udp.EnableBroadcast = true; #endif #if !NETSTANDARD udp.Send(bytes, bytes.Length, broadcastAddress); #else AsyncHelper.RunSync(() => udp.SendAsync(bytes, bytes.Length, broadcastAddress)); #endif var activeBefore = Interlocked.CompareExchange(ref _active, Active, Inactive); if (activeBefore == Active) { // If already started, we've nothing to do. return; } #if CF _bufferSize = 8192; #elif SSHARP _bufferSize = 16384; #else _bufferSize = udp.Client.ReceiveBufferSize = Messenger.MaxMessageSize; #endif #if ASYNC #if SSHARP ThreadPool.QueueUserWorkItem(AsyncBeginReceive, udp); #else Task.Factory.StartNew(() => AsyncBeginReceive(udp.Client)); #endif #else Task.Factory.StartNew(() => AsyncReceive(udp.Client)); #endif #if SSHARP CrestronEnvironment.Sleep(interval); #else Thread.Sleep(interval); #endif Interlocked.CompareExchange(ref _active, Inactive, Active); udp.Close(); } }