public async Task SendAsync(byte[] datagram, IPEndpoint remoteEndpoint)
{
foreach (UdpClient client in _clients)
{
await client.SendAsync(datagram, remoteEndpoint);
}
}
protected override Response SendRequest(Request request)
{
// RFC1035 max. size of a UDP datagram is 512 bytes
byte[] responseMessage = new byte[512];
for (int intAttempts = 0; intAttempts < Options.RetryCount; intAttempts++)
{
using (var datagramSocket = m_datagramSocketFactory.CreateDatagramSocket(Options.Timeout))
{
try
{
var address = IPAddress.Parse(DnsServerEndpoint.Address.ToString());
var endpoint = new IPEndpoint(address, (ushort)DnsServerEndpoint.Port);
datagramSocket.SendTo(request.Data, endpoint);
int intReceived = datagramSocket.Receive(responseMessage);
byte[] data = new byte[intReceived];
Array.Copy(responseMessage, data, intReceived);
Response response = new Response(DnsServerEndpoint, data);
CacheResponse(response);
return response;
}
catch (Exception/*SocketException*/)
{
continue;
}
finally
{
IncrementSequenceNumber();
}
}
}
Response responseTimeout = new Response();
responseTimeout.Error = "Timeout Error";
return responseTimeout;
}
public async Task <IEnumerable <WifiBridgeInfo> > DiscoverAsync(TimeSpan timeout)
{
var client = _networkService.CreateUdpBroadcastClient(48899);
var receivedPackets = new List <UdpReceiveResult>();
CancellationTokenSource tokenSource = new CancellationTokenSource();
DiscoverReceive(client, receivedPackets, tokenSource.Token);
// ReSharper disable MethodSupportsCancellation
int loops = (int)timeout.TotalMilliseconds / 50;
byte[] discoveryPacket = Encoding.UTF8.GetBytes("Link_Wi-Fi");
IPEndpoint endpoint = new IPEndpoint(IPAddress.Broadcast, 48899);
for (int i = 0; i < loops; i++)
{
await client.SendAsync(discoveryPacket, endpoint);
await Task.Delay(50);
}
await Task.Delay(200);
// ReSharper restore MethodSupportsCancellation
tokenSource.Cancel();
client.Dispose();
return(ParseReceivedDiscoveryPackets(receivedPackets));
}
private static Uri GetUri(IPEndpoint endpoint)
{
var uriScheme = endpoint.Port == 443 ? "https" : "http";
var uriString = String.Format(CultureInfo.InvariantCulture, "{0}://{1}:{2}", uriScheme, endpoint.Address, endpoint.Port);
var result = new Uri(uriString);
return(result);
}
public TCPEvent(DateTime timestamp, UInt32 resourceId, SocketEventType type,
IPEndpoint localEndpoint, IPEndpoint remoteEndpoint)
{
this.timestamp = timestamp;
this.resourceId = resourceId;
this.type = type;
this.localEndpoint = localEndpoint;
this.remoteEndpoint = remoteEndpoint;
}
public BrowserPageArgs(IServiceProvider serviceProvider, AppViewModel appViewModel, IPEndpoint endpoint)
: base(serviceProvider, appViewModel)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
m_endpoint = endpoint;
}
public UdpDnsResolver(DnsResolverOptions options, IDatagramSocketFactory datagramSocketFactory, IPEndpoint dnsServerEndpoint, Random random = null)
: base(options, dnsServerEndpoint, random)
{
if (datagramSocketFactory == null)
{
throw new ArgumentNullException("datagramSocketFactory");
}
m_datagramSocketFactory = datagramSocketFactory;
}
public TcpDnsResolver(DnsResolverOptions options, IStreamSocketFactory streamSocketFactory, IPEndpoint dnsServerEndpoint, Random random = null)
: base(options, dnsServerEndpoint, random)
{
if (streamSocketFactory == null)
{
throw new ArgumentNullException("streamSocketFactory");
}
m_streamSocketFactory = streamSocketFactory;
}
public void NavigateToBrowserPage(IPEndpoint endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
if (!Frame.Navigate(typeof(BrowserPage), new BrowserPageArgs(m_serviceProvider, this, endpoint)))
{
throw new Exception("Failed to create browser page");
}
}
public Response()
{
Questions = new List<Question>();
Answers = new List<AnswerRR>();
Authorities = new List<AuthorityRR>();
Additionals = new List<AdditionalRR>();
Server = new IPEndpoint(new IPAddress(0), 0);
Error = String.Empty;
MessageSize = 0;
TimeStamp = DateTime.Now;
header = new Header();
}
public Response()
{
Questions = new List <Question>();
Answers = new List <AnswerRR>();
Authorities = new List <AuthorityRR>();
Additionals = new List <AdditionalRR>();
Server = new IPEndpoint(new IPAddress(0), 0);
Error = String.Empty;
MessageSize = 0;
TimeStamp = DateTime.Now;
header = new Header();
}
public Rtu(string name, IPEndpoint hostAddres, ushort localDNP3Addres, ushort remoteDNP3Address)
{
//Considerando uma RTU por Canal
Channel = Core.DNP3Manager.AddTCPServer(name, LogLevels.ALL, ServerAcceptMode.CloseExisting, hostAddres.address, hostAddres.port, ChannelListener.Print());
Config = new OutstationStackConfig();
Config.databaseTemplate = new DatabaseTemplate(4, 0, 1, 1, 1, 1, 1, 0, 0);
Config.databaseTemplate.analogs[0].clazz = PointClass.Class2;
Config.outstation.config.allowUnsolicited = false;
Config.link.remoteAddr = remoteDNP3Address;
Config.link.localAddr = localDNP3Addres;
Outstation = Channel.AddOutstation(name, RejectingCommandHandler.Instance, DefaultOutstationApplication.Instance, Config);
Outstation.Enable();
}
protected DnsResolverBase(DnsResolverOptions options, IPEndpoint dnsServerEndpoint, Random random = null)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (dnsServerEndpoint == null)
{
throw new ArgumentNullException("dnsServerEndpoint");
}
m_options = options;
m_dnsServerEndpoint = dnsServerEndpoint;
m_sequenceNumber = (ushort)(random ?? new Random()).Next();
}
protected DnsResolverBase(DnsResolverOptions options, IPEndpoint dnsServerEndpoint, Random random = null)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (dnsServerEndpoint == null)
{
throw new ArgumentNullException("dnsServerEndpoint");
}
m_options = options;
m_dnsServerEndpoint = dnsServerEndpoint;
m_sequenceNumber = (ushort)(random ?? new Random()).Next();
}
public Rtu(int id, string name, IPEndpoint clientAddress, IPEndpoint hostAddres, ushort localDNP3Addres, ushort remoteDNP3Address,
Dictionary<int, int> bins, Dictionary<int, int> analogs, Dictionary<int, int> counters, DatabaseTemplate dt, GeminiMap gmap)
{
Id = id;
Name = name;
//Considerando uma RTU por Canal
if (Core.LoggingEnabled)
{
Channel = Core.DNP3Manager.AddTCPServer(name, LogLevels.ALL, ServerAcceptMode.CloseExisting, hostAddres.address, hostAddres.port, ChannelListener.Print());
}
else
{
Channel = Core.DNP3Manager.AddTCPServer(name, LogLevels.NONE, ServerAcceptMode.CloseExisting, hostAddres.address, hostAddres.port, ChannelListener.Print());
}
//Configuração Padrão de RTU é Outstation
Config = new OutstationStackConfig
{
databaseTemplate = dt
};
Config.link.remoteAddr = remoteDNP3Address;
Config.link.localAddr = localDNP3Addres;
DNP3ToSNMPBinaries = bins;
DNP3ToSNMPAnalogs = analogs;
DNP3ToSNMPCounters = counters;
Outstation = Channel.AddOutstation(name, RejectingCommandHandler.Instance, DefaultOutstationApplication.Instance, Config);
Outstation.Enable();
geminiMap = gmap;
Target = new SnmpTarget(clientAddress.address, clientAddress.port, Core.Settings.SNMPTimeout, Core.Settings.SNMPRetry);
foreach (KeyValuePair<int, int> map in DNP3ToSNMPBinaries)
{
Target.InsertObject(Core.OidLibrary.GetLabelFromId(map.Value), Core.OidLibrary.GetOidFromId(map.Value));
}
foreach (KeyValuePair<int, int> map in DNP3ToSNMPAnalogs)
{
Target.InsertObject(Core.OidLibrary.GetLabelFromId(map.Value), Core.OidLibrary.GetOidFromId(map.Value));
}
foreach (KeyValuePair<int, int> map in DNP3ToSNMPCounters)
{
Target.InsertObject(Core.OidLibrary.GetLabelFromId(map.Value), Core.OidLibrary.GetOidFromId(map.Value));
}
MonitorThread = new Timer(new TimerCallback(Update), null, TimeSpan.FromMilliseconds(10), TimeSpan.FromSeconds(Core.Settings.GatewayPoolingTime));
}
public ScanNetworkResult(Protocol protocol, IPEndpoint endpoint, string hostName, bool isAvailable)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
if (hostName != null && String.IsNullOrWhiteSpace(hostName))
{
throw new ArgumentException("Invalid host name", "hostName");
}
m_protocol = protocol;
m_endpoint = endpoint;
m_hostName = hostName;
m_isAvailable = isAvailable;
}
public static void ScanNetwork(CancellationToken userToken, DnsResolverBase resolver, IPAddressRange addresses, INetworkServiceCore[] networkServices, IProgress <ScanNetworkBatch> progress)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
if (addresses == null)
{
throw new ArgumentNullException("addresses");
}
if (networkServices == null)
{
throw new ArgumentNullException("networkServices");
}
if (progress == null)
{
throw new ArgumentNullException("progress");
}
var nestedTasks = new List <Task>();
var chunkSize = GetChunkSize(addresses);
foreach (var addressChunk in addresses.Chunk(chunkSize))
{
userToken.ThrowIfCancellationRequested();
var nestedTask = Task.Factory.StartNew(() =>
{
foreach (var address in addressChunk)
{
var results = new List <ScanNetworkResult>();
foreach (var networkService in networkServices)
{
userToken.ThrowIfCancellationRequested();
var endpoint = new IPEndpoint(address, networkService.Port);
var result = ScanEndpoint(userToken, resolver, networkService.Protocol, endpoint);
results.Add(result);
}
progress.Report(new ScanNetworkBatch(results.ToArray()));
}
});
nestedTasks.Add(nestedTask);
}
Task.WaitAll(nestedTasks.ToArray(), userToken);
}
private static string GetHostName(DnsResolverBase resolver, IPEndpoint endpoint)
{
if (resolver == null)
{
return(null);
}
var result = resolver.GetHostName(endpoint.Address);
#if SCREENSHOT
if (result != null)
{
result = result.Replace("example.com", "my-domain-name");
}
#endif
return(result);
}
public void SendTo(byte[] data, IPEndpoint endpoint)
{
Task.Factory.StartNew(async() =>
{
//try
//{
await m_socket.ConnectAsync(endpoint.Address.HostName, endpoint.Port.ToString(CultureInfo.InvariantCulture));
//}
//catch (Exception ex)
//{
// Logger.Trace("ConnectAsync failed: {0}", ex);
// throw;
//}
var writer = new DataWriter(m_socket.OutputStream);
writer.WriteBytes(data);
await writer.StoreAsync();
});
}
static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: CLRMasterGPRSTLSDemo.exe <ca certificate> <certificate chain> <private key>");
return(-1);
}
var caCertificate = args[0];
var certificateChain = args[1];
var privateKey = args[2];
var manager = DNP3SessionManagerFactory.CreateManager(4, new PrintingLogAdapter());
var listener = manager.CreateListener(
"listener",
LogLevels.ALL,
IPEndpoint.Localhost(20001),
new TLSConfig(caCertificate, certificateChain, privateKey, 2),
new DefaultListenCallbacks()
);
Console.WriteLine("Enter a command");
while (true)
{
switch (Console.ReadLine())
{
case "x":
// The manager does not automatically reclaim resources for stop executing threads in a finalizer
// Be sure to call this before exiting to cleanup all resources.
manager.Shutdown();
return(0);
default:
break;
}
}
}
static void Main(string[] args)
{
Core.Start();
SnmpTarget retAbelSantana = new SnmpTarget("10.7.5.150");
retAbelSantana.InsertObject("batteryTemperaturesValue", ".1.3.6.1.4.1.12148.10.10.7.5.0");
SnmpV2Packet result = retAbelSantana.GetUpdate();
IPEndpoint myEndPoint = new IPEndpoint("0.0.0.0", 20500);
Rtu rtu = new Rtu("Teste DNP3", myEndPoint, 2, 1);
ChangeSet changeSet;
int currentValue;
while (true)
{
if (result != null)
{
changeSet = new ChangeSet();
if (result.Pdu.ErrorStatus != 0)
{
Console.WriteLine("Error in SNMP reply. Error {0} index {1}",
result.Pdu.ErrorStatus,
result.Pdu.ErrorIndex);
}
else
{
currentValue = Convert.ToInt32(result.Pdu.VbList[0].Value.ToString());
changeSet.Update(new Analog(currentValue, 1, DateTime.Now), 0);
Console.WriteLine("Atualizando valor da analógica para " + currentValue);
rtu.Outstation.Load(changeSet);
}
}
else
{
Console.WriteLine("Erro SNMP Nulo");
}
Thread.Sleep(15000);
}
}
static int Main(string[] args)
{
var manager = DNP3ManagerFactory.CreateManager(4, new PrintingLogAdapter());
var listener = manager.CreateListener("listener", LogLevels.ALL, IPEndpoint.Localhost(20000), new DefaultListenCallbacks());
Console.WriteLine("Enter a command");
while (true)
{
switch (Console.ReadLine())
{
case "x":
// The manager does not automatically reclaim resources for stop executing threads in a finalizer
// Be sure to call this before exiting to cleanup all resources.
manager.Shutdown();
return(0);
default:
break;
}
}
}
public Response(IPEndpoint endpoint, byte[] data)
{
Error = String.Empty;
Server = endpoint;
TimeStamp = DateTime.Now;
MessageSize = data.Length;
RecordReader rr = new RecordReader(data);
Questions = new List<Question>();
Answers = new List<AnswerRR>();
Authorities = new List<AuthorityRR>();
Additionals = new List<AdditionalRR>();
header = new Header(rr);
//if (header.RCODE != RCode.NoError)
// Error = header.RCODE.ToString();
for (int intI = 0; intI < header.QDCOUNT; intI++)
{
Questions.Add(new Question(rr));
}
for (int intI = 0; intI < header.ANCOUNT; intI++)
{
Answers.Add(new AnswerRR(rr));
}
for (int intI = 0; intI < header.NSCOUNT; intI++)
{
Authorities.Add(new AuthorityRR(rr));
}
for (int intI = 0; intI < header.ARCOUNT; intI++)
{
Additionals.Add(new AdditionalRR(rr));
}
}
public Response(IPEndpoint endpoint, byte[] data)
{
Error = String.Empty;
Server = endpoint;
TimeStamp = DateTime.Now;
MessageSize = data.Length;
RecordReader rr = new RecordReader(data);
Questions = new List <Question>();
Answers = new List <AnswerRR>();
Authorities = new List <AuthorityRR>();
Additionals = new List <AdditionalRR>();
header = new Header(rr);
//if (header.RCODE != RCode.NoError)
// Error = header.RCODE.ToString();
for (int intI = 0; intI < header.QDCOUNT; intI++)
{
Questions.Add(new Question(rr));
}
for (int intI = 0; intI < header.ANCOUNT; intI++)
{
Answers.Add(new AnswerRR(rr));
}
for (int intI = 0; intI < header.NSCOUNT; intI++)
{
Authorities.Add(new AuthorityRR(rr));
}
for (int intI = 0; intI < header.ARCOUNT; intI++)
{
Additionals.Add(new AdditionalRR(rr));
}
}
protected override Response SendRequest(Request request)
{
// RFC1035 max. size of a UDP datagram is 512 bytes
byte[] responseMessage = new byte[512];
for (int intAttempts = 0; intAttempts < Options.RetryCount; intAttempts++)
{
using (var datagramSocket = m_datagramSocketFactory.CreateDatagramSocket(Options.Timeout))
{
try
{
var address = IPAddress.Parse(DnsServerEndpoint.Address.ToString());
var endpoint = new IPEndpoint(address, (ushort)DnsServerEndpoint.Port);
datagramSocket.SendTo(request.Data, endpoint);
int intReceived = datagramSocket.Receive(responseMessage);
byte[] data = new byte[intReceived];
Array.Copy(responseMessage, data, intReceived);
Response response = new Response(DnsServerEndpoint, data);
CacheResponse(response);
return(response);
}
catch (Exception /*SocketException*/)
{
continue;
}
finally
{
IncrementSequenceNumber();
}
}
}
Response responseTimeout = new Response();
responseTimeout.Error = "Timeout Error";
return(responseTimeout);
}
public UdpDnsResolver(DnsResolverOptions options, IDatagramSocketFactory datagramSocketFactory, IPEndpoint dnsServerEndpoint, Random random = null)
: base(options, dnsServerEndpoint, random)
{
if (datagramSocketFactory == null)
{
throw new ArgumentNullException("datagramSocketFactory");
}
m_datagramSocketFactory = datagramSocketFactory;
}
public async Task SendAsync(byte[] datagram, IPEndpoint remoteEndpoint)
{
await _client.SendAsync(datagram, datagram.Length, new IPEndPoint(System.Net.IPAddress.Parse(remoteEndpoint.Address), remoteEndpoint.Port));
}
public Task SendAsync(byte[] datagram, IPEndpoint remoteEndpoint)
{
throw new NotImplementedException();
}
public IUdpClient CreateUdpClient(IPEndpoint localEndpoint)
{
return(new UdpClient(localEndpoint));
}
public UdpReceiveResult(byte[] data, IPEndpoint remoteEndpoint)
{
Data = data;
RemoteEndpoint = remoteEndpoint;
}
private static ScanNetworkResult ScanEndpoint(CancellationToken userToken, DnsResolverBase resolver, Protocol protocol, IPEndpoint endpoint)
{
var status = Ping.PerformPing(endpoint, protocol);
var hostName = status ? GetHostName(resolver, endpoint) : null;
var result = new ScanNetworkResult(protocol, endpoint, hostName, status);
return(result);
}
public TcpDnsResolver(DnsResolverOptions options, IStreamSocketFactory streamSocketFactory, IPEndpoint dnsServerEndpoint, Random random = null)
: base(options, dnsServerEndpoint, random)
{
if (streamSocketFactory == null)
{
throw new ArgumentNullException("streamSocketFactory");
}
m_streamSocketFactory = streamSocketFactory;
}
public UdpClient(IPEndpoint localEndpoint)
{
_client = new System.Net.Sockets.UdpClient(new IPEndPoint(System.Net.IPAddress.Parse(localEndpoint.Address), localEndpoint.Port));
//_client = new System.Net.Sockets.UdpClient(localEndpoint.Host, localEndpoint.Port);
}
public void SendTo(byte[] data, IPEndpoint endpoint)
{
m_socketFactory.m_sendToInvokedHandler(data, endpoint);
}
static void Main(string[] args)
{
PacketStream stream = new PacketStream();
IPEndpoint localEndpoint = new IPEndpoint("169.254.2.2", 27516);
IPEndpoint remoteEndpoint = new IPEndpoint("169.254.2.1", 1056);
int n = 1;
IPPacket p = new IPPacket(n++, 1, PacketDirection.PACKET_DIRECTION_OUTGOING, localEndpoint, remoteEndpoint,
NewArrayIncremental(6, 10));
stream.AppendPacket(p);
p = new IPPacket(n++, 1, PacketDirection.PACKET_DIRECTION_OUTGOING, localEndpoint, remoteEndpoint,
NewArrayIncremental(3, 35));
stream.AppendPacket(p);
p = new IPPacket(n++, 1, PacketDirection.PACKET_DIRECTION_OUTGOING, localEndpoint, remoteEndpoint,
NewArrayIncremental(1, 60));
stream.AppendPacket(p);
p = new IPPacket(n++, 1, PacketDirection.PACKET_DIRECTION_OUTGOING, localEndpoint, remoteEndpoint,
NewArrayIncremental(1, 200));
stream.AppendPacket(p);
p = new IPPacket(n++, 1, PacketDirection.PACKET_DIRECTION_OUTGOING, localEndpoint, remoteEndpoint,
NewArrayIncremental(3, 210));
stream.AppendPacket(p);
p = new IPPacket(n++, 1, PacketDirection.PACKET_DIRECTION_OUTGOING, localEndpoint, remoteEndpoint,
NewArrayIncremental(1, 70));
stream.AppendPacket(p);
p = new IPPacket(n++, 1, PacketDirection.PACKET_DIRECTION_OUTGOING, localEndpoint, remoteEndpoint,
NewArrayIncremental(1, 80));
stream.AppendPacket(p);
Debug.Assert(stream.Position == 0, "Position != 0");
Debug.Assert(stream.Length == 16, "Length != 16");
byte[] buf = new byte[stream.Length];
Debug.Assert(stream.Read(buf, 0, 16) == 16, "Read() != 16");
byte[] expectedBytes = new byte[] { 10, 11, 12, 13, 14, 15,
35, 36, 37,
60,
200,
210, 211, 212,
70,
80 };
Debug.Assert(CompareByteArrays(buf, expectedBytes), "Content after first read is not as expected");
Debug.Assert(stream.Position == 16, "Position != 16");
Debug.Assert(stream.Read(buf, 0, 10) == 0, "Read at offset 16 doesn't return 0");
stream.Seek(-1, SeekOrigin.Current);
Debug.Assert(stream.Read(buf, 2, 100) == 1, "Read at offset 15 doesn't return 1");
Debug.Assert(buf[2] == 80, "Byte at offset 15 isn't 80");
stream.Seek(-16, SeekOrigin.Current);
Debug.Assert(stream.Position == 0, "Position != 0 after reverse seek");
stream.Position = 9;
Debug.Assert(stream.Read(buf, 1, 1) == 1, "Read at Position=9 didn't yield 1 byte");
Debug.Assert(buf[1] == 60, "buf[1] != 60");
stream.Position = 13;
Debug.Assert(stream.Read(buf, 5, 4) == 3, "Read at Position=13 didn't yield 3 bytes");
Debug.Assert(buf[5] == 212, "buf[5] != 212");
Debug.Assert(buf[6] == 70, "buf[5] != 70");
Debug.Assert(buf[7] == 80, "buf[5] != 80");
System.Console.WriteLine("All tests passed");
System.Console.ReadKey();
}
public VisualSession(IPSession session)
{
localEndpoint = session.LocalEndpoint;
remoteEndpoint = session.RemoteEndpoint;
transactions = new List <VisualTransaction>();
}
