private static void AppendRange(StringBuilder b, PortRange range)
{
string rangeString = range.ToString();
if (rangeString != null)
{
b.Append(range);
b.Append(',');
}
}
public void TestParsing3c()
{
PortRange.TryParse("0-1;3-4;6-*", out var range1);
Assert.Equal(new PortRange(0, 1), range1.First());
Assert.Equal(new PortRange(3, 4), range1.Skip(1).First());
Assert.Equal(new PortRange(6, 65536), range1.Skip(2).First());
Assert.Equal(3, range1.Count());
Assert.Equal("0-1;3-4;6-*", PortRange.Format(range1));
}
public void TestParsing3()
{
PortRange.TryParse("0,3,6,,,,", out var range1);
Assert.Equal(new PortRange(0), range1.First());
Assert.Equal(new PortRange(3), range1.Skip(1).First());
Assert.Equal(new PortRange(6), range1.Skip(2).First());
Assert.Equal(3, range1.Count());
Assert.Equal("0;3;6", PortRange.Format(range1));
}
public void TestNoneEquality2()
{
var range1 = new PortRange(0, 4);
var range2 = new PortRange(7, 9);
Assert.NotEqual(range1, range2);
Assert.True(range1 != range2);
Assert.False(range1 == range2);
Assert.False(range1.Overlaps(range2));
}
public void TestParsing2()
{
PortRange.TryParse("0-100;44", out var range1);
var range2 = new PortRange(0, 100);
var range3 = new PortRange(44);
Assert.Equal(range2, range1.First());
Assert.Equal(range3, range1.Skip(1).First());
Assert.Equal(2, range1.Count());
}
public void TestSimpleRange()
{
var range1 = new PortRange(0, 100);
var range2 = new PortRange(100, 0);
Assert.Equal(101, range1.Count);
Assert.Equal(range1, range2);
Assert.False(range1 != range2);
Assert.True(range1 == range2);
}
/// <summary>
/// Gets the first free port within the port range.
/// </summary>
/// <param name="pr">Enum to specify which range of
/// ports to receive and to check for availability.</param>
/// <param name="checkAvailability">TRUE to perform an
/// availability check on the ports.</param>
/// <returns>Returns the first free port.</returns>
public static int GetAvailablePort(PortRange pr, bool checkAvailability)
{
int[] ports = null;
if (checkAvailability)
{
ports = GetAvailablePorts(pr, true);
}
else
{
ports = GetPorts(pr);
}
return(ports[0]);
}
private void commitService( bool modify )
{
if (portsAndProtoListView.Items.Count == 0) return; // Not interested
var service = new Service(serviceNameBox.Text);
foreach (ListViewItem item in portsAndProtoListView.Items)
{
PortRange port_range = new PortRange();
var ret = port_range.parseRange(item.Text);
Debug.Assert(ret); // We should have already validated this
Protocols protocols;
switch (item.SubItems[1].Text)
{
case "TCP":
protocols = Protocols.TCP;
break;
case "UDP":
protocols = Protocols.UDP;
break;
case "Both":
protocols = Protocols.BOTH;
break;
default:
protocols = Protocols.TCP; // Just to make the compiler happy
Debug.Assert(false, "Bad case!");
break;
}
port_range.protocols = protocols;
service.port_ranges.Add( port_range );
}
var bs = (BindingSource)servicesListBox.DataSource;
bs.Add(service);
if (modify)
{
bs.RemoveCurrent();
}
_services.Sort();
refreshServices(); // Reordered, need to refresh
servicesListBox.SelectedItem = service;
}
private static void ComputeKernelSpecArgs(PortRange httpPortRange, DirectoryInfo directory)
{
var kernelSpecs = directory.GetFiles("kernel.json", SearchOption.AllDirectories);
foreach (var kernelSpec in kernelSpecs)
{
var parsed = JObject.Parse(File.ReadAllText(kernelSpec.FullName));
var argv = parsed["argv"].Value <JArray>();
argv.Insert(argv.Count - 1, "--http-port-range");
argv.Insert(argv.Count - 1, $"{httpPortRange.Start}-{httpPortRange.End}");
File.WriteAllText(kernelSpec.FullName, parsed.ToString(Newtonsoft.Json.Formatting.Indented));
}
}
public void Holds_Data()
{
// arrange
var start = 11111;
var end = 22222;
// act
var range = new PortRange
{
Start = start,
End = end
};
// assert
Assert.Equal(start, range.Start);
Assert.Equal(end, range.End);
}
public void TestFullRange()
{
using (var ctx = new Context())
{
var range = new PortRange
{
Low = 0,
High = ushort.MaxValue
};
string portVariableName = "port";
BitVecExpr variable = ctx.MkConst(portVariableName, ctx.MkBitVecSort(16)) as BitVecExpr;
Solver s = ctx.MkSolver();
s.Assert(ctx.MkNot(range.Contains(ctx, variable)));
Status result = s.Check();
Assert.AreEqual(Status.UNSATISFIABLE, result);
}
}
public void TestSingle()
{
using (var ctx = new Context())
{
int single = 64;
var range = new PortRange
{
Low = single,
High = single
};
string portVariableName = "port";
BitVecExpr variable = ctx.MkConst(portVariableName, ctx.MkBitVecSort(16)) as BitVecExpr;
Solver s = ctx.MkSolver();
s.Assert(range.Contains(ctx, variable));
Status result = s.Check();
Assert.AreEqual(Status.SATISFIABLE, result);
int binding;
Assert.IsTrue(RetrieveModelValue.TryRetrieveInteger(portVariableName, s.Model, out binding));
Assert.AreEqual(single, binding);
}
}
private void ParseFirewallBlockRules()
{
string firewallBlockRuleString = null;
GetConfig <string>("FirewallRules", ref firewallBlockRuleString);
firewallBlockRuleString = (firewallBlockRuleString ?? string.Empty).Trim();
if (firewallBlockRuleString.Length == 0)
{
return;
}
IEnumerable <string> firewallBlockRuleList = firewallBlockRuleString.Trim().Split('\n').Select(s => s.Trim()).Where(s => s.Length != 0);
foreach (string firewallBlockRule in firewallBlockRuleList)
{
string[] pieces = firewallBlockRule.Split(';');
if (pieces.Length == 5)
{
IPBanFirewallRule firewallBlockRuleObj = new IPBanFirewallRule
{
Block = (pieces[1].Equals("block", StringComparison.OrdinalIgnoreCase)),
IPAddressRanges = pieces[2].Split(',').Select(p => IPAddressRange.Parse(p)).ToList(),
Name = "EXTRA_" + pieces[0].Trim(),
AllowPortRanges = pieces[3].Split(',').Select(p => PortRange.Parse(p)).Where(p => p.MinPort >= 0).ToList(),
PlatformRegex = new Regex(pieces[4].Replace('*', '.'), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)
};
if (firewallBlockRuleObj.PlatformRegex.IsMatch(IPBanOS.Name))
{
extraRules.Add(firewallBlockRuleObj);
}
}
else
{
IPBanLog.Warn("Firewall block rule entry should have 3 comma separated pieces: name;ips;ports. Invalid entry: {0}", firewallBlockRule);
}
}
}
/// <summary>
/// Picks a random port from a port range.
/// </summary>
/// <param name="portRanges">Port range.</param>
/// <returns>A random port from the port range.</returns>
public int PickRandomPort(List <List <int> > portRanges)
{
var randomPortsRanges = new Dictionary <string, PortRange>();
var totalWeightScore = 0;
foreach (var portRangeList in portRanges)
{
var from = portRangeList.First();
var to = portRangeList.Last();
var totalPorts = Math.Abs(to - from) + 1;
if (from > to)
{
var tmpTo = to;
to = from;
from = tmpTo;
}
var portRange = new PortRange()
{
From = from,
To = to,
Count = totalPorts,
Weight = 0,
};
totalWeightScore += totalPorts;
randomPortsRanges.Add(string.Format("{0},{1}", from, to), portRange);
}
// Sort out the weights
foreach (var key in randomPortsRanges.Keys.ToList())
{
var rangeWithWeight = randomPortsRanges[key];
rangeWithWeight.Weight = (uint)Math.Ceiling((double)randomPortsRanges[key].Count / (double)totalWeightScore * RandomnessPrecision);
randomPortsRanges[key] = rangeWithWeight;
}
// Pick one range, based on weight
byte[] randomBlob = new byte[sizeof(uint)];
byte[] randomPortBlob = new byte[sizeof(ushort)];
var rngProvider = new RNGCryptoServiceProvider();
rngProvider.GetBytes(randomBlob);
var returnPort = 53;
var randomNumber = BitConverter.ToUInt32(randomBlob, 0) % (RandomnessPrecision + 1);
try
{
foreach (var key in randomPortsRanges.Keys.ToList())
{
if (randomNumber <= randomPortsRanges[key].Weight)
{
rngProvider.GetBytes(randomPortBlob);
var randomPortNumber = BitConverter.ToUInt16(randomPortBlob, 0);
returnPort = (randomPortNumber % (randomPortsRanges[key].To + 1 - randomPortsRanges[key].From)) + randomPortsRanges[key].From;
break;
}
randomNumber -= randomPortsRanges[key].Weight;
}
}
finally
{
rngProvider.Dispose();
}
return(returnPort);
}
public JupyterInstallCommand(IConsole console, IJupyterKernelSpec jupyterKernelSpec, PortRange httpPortRange = null)
{
_console = console;
_jupyterKernelSpec = jupyterKernelSpec;
_httpPortRange = httpPortRange;
}
/// <summary>
/// Create request wrapper
/// </summary>
/// <param name="request"></param>
/// <param name="networkClass"></param>
/// <param name="isScan"></param>
public DiscoveryRequest(DiscoveryRequestModel request,
NetworkClass networkClass = NetworkClass.Wired, bool isScan = false)
{
Request = request?.Clone() ?? throw new ArgumentNullException(nameof(request));
_cts = new CancellationTokenSource();
NetworkClass = networkClass;
IsScan = isScan;
if (Request.Configuration == null)
{
Request.Configuration = new DiscoveryConfigModel();
}
if (Request.Discovery == null ||
Request.Discovery == DiscoveryMode.Off)
{
// Report empty configuration if off, but keep the
// discovery urls details from the original request
Request.Configuration = new DiscoveryConfigModel()
{
ActivationFilter = Request.Configuration.ActivationFilter?.Clone(),
DiscoveryUrls = Request.Configuration.DiscoveryUrls?.ToList(),
Locales = Request.Configuration.Locales?.ToList()
};
Request.Discovery = DiscoveryMode.Off;
return;
}
// Parse whatever provided
if (!string.IsNullOrEmpty(Request.Configuration.PortRangesToScan))
{
if (PortRange.TryParse(Request.Configuration.PortRangesToScan,
out var ports))
{
PortRanges = ports;
if (Request.Discovery == null)
{
Request.Discovery = DiscoveryMode.Fast;
}
}
}
if (!string.IsNullOrEmpty(Request.Configuration.AddressRangesToScan))
{
if (AddressRange.TryParse(Request.Configuration.AddressRangesToScan,
out var addresses))
{
AddressRanges = addresses;
if (Request.Discovery == null)
{
Request.Discovery = DiscoveryMode.Fast;
}
}
}
// Set default ranges
if (AddressRanges == null)
{
IEnumerable <NetInterface> interfaces;
switch (Request.Discovery)
{
case DiscoveryMode.Local:
interfaces = NetworkInformationEx.GetAllNetInterfaces(NetworkClass);
AddressRanges = AddLocalHost(interfaces
.Select(t => new AddressRange(t, true)))
.Distinct();
break;
case DiscoveryMode.Fast:
interfaces = NetworkInformationEx.GetAllNetInterfaces(NetworkClass.Wired);
AddressRanges = AddLocalHost(interfaces
.Select(t => new AddressRange(t, false, 24))
.Concat(interfaces
.Where(t => t.Gateway != null &&
!t.Gateway.Equals(IPAddress.Any) &&
!t.Gateway.Equals(IPAddress.None))
.Select(i => new AddressRange(i.Gateway, 32)))
.Distinct());
break;
case DiscoveryMode.Network:
case DiscoveryMode.Scan:
interfaces = NetworkInformationEx.GetAllNetInterfaces(NetworkClass);
AddressRanges = AddLocalHost(interfaces
.Select(t => new AddressRange(t, false))
.Concat(interfaces
.Where(t => t.Gateway != null &&
!t.Gateway.Equals(IPAddress.Any) &&
!t.Gateway.Equals(IPAddress.None))
.Select(i => new AddressRange(i.Gateway, 32)))
.Distinct());
break;
case DiscoveryMode.Off:
default:
AddressRanges = Enumerable.Empty <AddressRange>();
break;
}
}
if (PortRanges == null)
{
switch (Request.Discovery)
{
case DiscoveryMode.Local:
PortRanges = PortRange.All;
break;
case DiscoveryMode.Fast:
PortRanges = PortRange.WellKnown;
break;
case DiscoveryMode.Scan:
PortRanges = PortRange.Unassigned;
break;
case DiscoveryMode.Network:
PortRanges = PortRange.OpcUa;
break;
case DiscoveryMode.Off:
default:
PortRanges = Enumerable.Empty <PortRange>();
break;
}
}
// Update reported configuration with used settings
if (AddressRanges != null && AddressRanges.Any())
{
Request.Configuration.AddressRangesToScan = AddressRange.Format(AddressRanges);
TotalAddresses = AddressRanges?.Sum(r => r.Count) ?? 0;
}
if (PortRanges != null && PortRanges.Any())
{
Request.Configuration.PortRangesToScan = PortRange.Format(PortRanges);
TotalPorts = PortRanges?.Sum(r => r.Count) ?? 0;
}
Request.Configuration.IdleTimeBetweenScans ??= kDefaultIdleTime;
Request.Configuration.PortProbeTimeout ??= kDefaultPortProbeTimeout;
Request.Configuration.NetworkProbeTimeout ??= kDefaultNetworkProbeTimeout;
}
private void createNetworkAclEntry(string networkAclId, int ruleNumber, string cidrBlock, bool egress, string protocol, PortRange portRange, RuleAction ruleAction)
{
CreateNetworkAclEntryRequest createNetworkAclEntryRequest = new CreateNetworkAclEntryRequest();
createNetworkAclEntryRequest.NetworkAclId = networkAclId;
createNetworkAclEntryRequest.RuleNumber = ruleNumber;
createNetworkAclEntryRequest.CidrBlock = cidrBlock;
createNetworkAclEntryRequest.Egress = egress;
createNetworkAclEntryRequest.Protocol = protocol;
createNetworkAclEntryRequest.PortRange = portRange;
createNetworkAclEntryRequest.RuleAction = ruleAction;
CreateNetworkAclEntryResponse createNetworkAclEntryResponse = EC2_CLIENT.CreateNetworkAclEntryAsync(createNetworkAclEntryRequest).GetAwaiter().GetResult();
}
private async Task CreateNetworkAclEntry(string networkAclId, int ruleNumber, string cidrBlock, bool egress, string protocol, PortRange portRange, RuleAction ruleAction)
{
CreateNetworkAclEntryRequest createNetworkAclEntryRequest = new CreateNetworkAclEntryRequest();
createNetworkAclEntryRequest.NetworkAclId = networkAclId;
createNetworkAclEntryRequest.RuleNumber = ruleNumber;
createNetworkAclEntryRequest.CidrBlock = cidrBlock;
createNetworkAclEntryRequest.Egress = egress;
createNetworkAclEntryRequest.Protocol = protocol;
createNetworkAclEntryRequest.PortRange = portRange;
createNetworkAclEntryRequest.RuleAction = ruleAction;
CreateNetworkAclEntryResponse createNetworkAclEntryResponse = await ec2Client.CreateNetworkAclEntryAsync(createNetworkAclEntryRequest);
}
/// <summary>
/// Gets the first free port within the port range.
/// </summary>
/// <param name="pr">Enum to specify which range of
/// ports to receive.</param>
/// <returns>Returns the first free port.</returns>
public static int GetAvailablePort(PortRange pr)
{
int[] ports = GetPorts(pr);
return(ports[0]);
}
public JupyterInstallCommand(IConsole console, IJupyterKernelSpecInstaller jupyterKernelSpecInstaller, PortRange httpPortRange = null, DirectoryInfo path = null)
{
_console = console;
_jupyterKernelSpecInstaller = jupyterKernelSpecInstaller;
_httpPortRange = httpPortRange;
_path = path;
}
public void TestParsing4()
{
PortRange.TryParse(",,,,", out var range1);
Assert.Empty(range1);
}
/// <summary>
/// Create request wrapper
/// </summary>
/// <param name="request"></param>
/// <param name="networkClass"></param>
/// <param name="isScan"></param>
public DiscoveryRequest(DiscoveryRequestModel request,
NetworkClass networkClass = NetworkClass.Wired, bool isScan = false)
{
Request = request?.Clone() ?? throw new ArgumentNullException(nameof(request));
_cts = new CancellationTokenSource();
NetworkClass = networkClass;
IsScan = isScan;
if (!string.IsNullOrEmpty(request.Configuration?.AddressRangesToScan))
{
if (AddressRange.TryParse(request.Configuration?.AddressRangesToScan,
out var addresses))
{
AddressRanges = addresses;
}
}
if (AddressRanges == null)
{
if (request.Discovery == DiscoveryMode.Fast)
{
var interfaces = NetworkInformationEx.GetAllNetInterfaces(NetworkClass.Wired);
AddressRanges = interfaces.Select(t => new AddressRange(t, false, 24));
AddressRanges = AddressRanges.Concat(interfaces
.Where(t => t.Gateway != null &&
!t.Gateway.Equals(System.Net.IPAddress.Any) &&
!t.Gateway.Equals(System.Net.IPAddress.None))
.Select(i => new AddressRange(i.Gateway, 32)));
}
}
if (!string.IsNullOrEmpty(request.Configuration?.PortRangesToScan))
{
if (PortRange.TryParse(request.Configuration?.PortRangesToScan,
out var ports))
{
PortRanges = ports;
}
}
if (PortRanges == null)
{
switch (request.Discovery)
{
case DiscoveryMode.Local:
PortRanges = PortRange.All;
break;
case DiscoveryMode.Fast:
PortRanges = PortRange.WellKnown;
break;
case DiscoveryMode.Scan:
PortRanges = PortRange.Unassigned;
break;
default:
PortRanges = PortRange.OpcUa;
break;
}
}
TotalAddresses = AddressRanges?.Sum(r => r.Count) ?? 0;
TotalPorts = PortRanges?.Sum(r => r.Count) ?? 0;
}
static async Task FqdnScanAsync(ConsoleService c, string cmdName, string str)
{
ConsoleParam[] args =
{
new ConsoleParam("[subnets]", ConsoleService.Prompt, "Subnets: ", ConsoleService.EvalNotEmpty, null),
new ConsoleParam("servers"),
new ConsoleParam("threads"),
new ConsoleParam("interval"),
new ConsoleParam("try"),
new ConsoleParam("shuffle"),
new ConsoleParam("fqdnorder"),
new ConsoleParam("dest"),
new ConsoleParam("ports"),
};
ConsoleParamValueList vl = c.ParseCommandList(cmdName, str, args);
string subnets = vl.DefaultParam.StrValue;
string servers = vl["servers"].StrValue;
int threads = vl["threads"].IntValue;
int interval = vl["interval"].IntValue;
int numtry = vl["try"].IntValue;
bool shuffle = vl["shuffle"].StrValue._ToBool(true);
bool fqdnorder = vl["fqdnorder"].StrValue._ToBool(true);
string csv = vl["dest"].StrValue;
string portsStr = vl["ports"].StrValue;
PortRange portRange = new PortRange(portsStr);
var serversList = servers._Split(StringSplitOptions.RemoveEmptyEntries, " ", " ", ",", "|");
if (serversList._IsEmpty())
{
serversList = new string[] { "8.8.8.8", "8.8.4.4", "1.1.1.1", "3.3.3.3" };
}
List <IPEndPoint> endPointsList = new List <IPEndPoint>();
serversList._DoForEach(x => endPointsList.Add(new IPEndPoint(x._ToIPAddress() !, 53)));
using DnsHostNameScanner scan = new DnsHostNameScanner(
settings: new DnsHostNameScannerSettings { Interval = interval, NumThreads = threads, NumTry = numtry, PrintStat = true, RandomInterval = true, Shuffle = shuffle, PrintOrderByFqdn = fqdnorder, TcpPorts = portRange.ToArray(), },
dnsSettings: new DnsResolverSettings(dnsServersList: endPointsList, flags: DnsResolverFlags.UdpOnly | DnsResolverFlags.RoundRobinServers));
var list = await scan.PerformAsync(subnets);
if (csv._IsFilled())
{
using var csvWriter = Lfs.WriteCsv <FqdnScanResult>(csv, false, true, writeBom: false, flags: FileFlags.AutoCreateDirectory);
foreach (var item in list)
{
if (item.HostnameList._IsFilled())
{
FqdnScanResult r = new FqdnScanResult();
r.IpSortKey = IPAddr.FromAddress(item.Ip).GetZeroPaddingFullString();
r.Ip = item.Ip.ToString();
r.FqdnSortKey = Str.ReverseFqdnStr(item.HostnameList.First()).ToLowerInvariant();
r.FqdnList = item.HostnameList._Combine(" / ");
r.TcpPortList = item.TcpPorts.Select(x => x.ToString())._Combine(" / ");
csvWriter.WriteData(r);
}
}
}
}
/// <summary>
/// Creates a new RTP channel. The RTP and optionally RTCP sockets will be bound in the constructor.
/// They do not start receiving until the Start method is called.
/// </summary>
/// <param name="createControlSocket">Set to true if a separate RTCP control socket should be created. If RTP and
/// RTCP are being multiplexed (as they are for WebRTC) there's no need to a separate control socket.</param>
/// <param name="bindAddress">Optional. An IP address belonging to a local interface that will be used to bind
/// the RTP and control sockets to. If left empty then the IPv6 any address will be used if IPv6 is supported
/// and fallback to the IPv4 any address.</param>
/// <param name="bindPort">Optional. The specific port to attempt to bind the RTP port on.</param>
public RTPChannel(bool createControlSocket, IPAddress bindAddress, int bindPort = 0, PortRange rtpPortRange = null)
{
NetServices.CreateRtpSocket(createControlSocket, bindAddress, bindPort, rtpPortRange, out var rtpSocket, out m_controlSocket);
if (rtpSocket == null)
{
throw new ApplicationException("The RTP channel was not able to create an RTP socket.");
}
else if (createControlSocket && m_controlSocket == null)
{
throw new ApplicationException("The RTP channel was not able to create a Control socket.");
}
RtpSocket = rtpSocket;
RTPLocalEndPoint = RtpSocket.LocalEndPoint as IPEndPoint;
RTPPort = RTPLocalEndPoint.Port;
ControlLocalEndPoint = (m_controlSocket != null) ? m_controlSocket.LocalEndPoint as IPEndPoint : null;
ControlPort = (m_controlSocket != null) ? ControlLocalEndPoint.Port : 0;
}
/* Creates an array of ports which can be used.
** Returns only the ports which are within the
** specified range of ports.
** Returns the ports of range 14415 to 14935 as
** default. */
private static int[] GetPorts(PortRange pr)
{
switch (pr)
{
case PortRange.PR_14415_14935:
{
return(GetRange(14415, 14935));
}
case PortRange.PR_21011_21552:
{
return(GetRange(21011, 21552));
}
case PortRange.PR_26490_26999:
{
return(GetRange(26490, 26999));
}
case PortRange.PR_28590_29117:
{
return(GetRange(28590, 29117));
}
case PortRange.PR_29170_29998:
{
return(GetRange(29170, 29998));
}
case PortRange.PR_30261_30831:
{
return(GetRange(30261, 30831));
}
case PortRange.PR_33657_34248:
{
return(GetRange(33657, 34248));
}
case PortRange.PR_35358_36000:
{
return(GetRange(35358, 36000));
}
case PortRange.PR_36866_37474:
{
return(GetRange(36866, 37474));
}
case PortRange.PR_38204_38799:
{
return(GetRange(38204, 38799));
}
case PortRange.PR_38866_39680:
{
return(GetRange(38866, 39680));
}
case PortRange.PR_41231_41793:
{
return(GetRange(41231, 41793));
}
case PortRange.PR_41798_42507:
{
return(GetRange(41798, 42507));
}
case PortRange.PR_43442_44122:
{
return(GetRange(43442, 44122));
}
case PortRange.PR_46337_46997:
{
return(GetRange(46337, 46997));
}
default:
{
return(GetRange(14415, 14935));
}
}
}
/// <summary>
/// Gets the ports requested.
/// </summary>
/// <returns></returns>
public ushort[] GetPortsRequested()
{
return(PortRange.GetPortList(ioBase, 0x2F));
}
/// <summary>
/// Create request wrapper
/// </summary>
/// <param name="request"></param>
/// <param name="networkClass"></param>
/// <param name="isScan"></param>
public DiscoveryRequest(DiscoveryRequestModel request,
NetworkClass networkClass = NetworkClass.Wired, bool isScan = false)
{
Request = request?.Clone() ?? throw new ArgumentNullException(nameof(request));
_cts = new CancellationTokenSource();
NetworkClass = networkClass;
IsScan = isScan;
if (request == null)
{
request = new DiscoveryRequestModel {
Discovery = DiscoveryMode.Off
};
}
if (request.Configuration == null)
{
request.Configuration = new DiscoveryConfigModel();
}
if (!string.IsNullOrEmpty(request.Configuration.AddressRangesToScan))
{
if (AddressRange.TryParse(request.Configuration.AddressRangesToScan,
out var addresses))
{
AddressRanges = addresses;
}
}
if (AddressRanges == null)
{
switch (request.Discovery)
{
case DiscoveryMode.Local:
AddressRanges = NetworkInformationEx.GetAllNetInterfaces(NetworkClass)
.Select(t => new AddressRange(t, true)).Distinct();
break;
case DiscoveryMode.Fast:
var interfaces = NetworkInformationEx.GetAllNetInterfaces(NetworkClass.Wired);
AddressRanges = interfaces.Select(t => new AddressRange(t, false, 24));
AddressRanges = AddressRanges.Concat(interfaces
.Where(t => t.Gateway != null &&
!t.Gateway.Equals(System.Net.IPAddress.Any) &&
!t.Gateway.Equals(System.Net.IPAddress.None))
.Select(i => new AddressRange(i.Gateway, 32)));
break;
case DiscoveryMode.Off:
AddressRanges = Enumerable.Empty <AddressRange>();
break;
case DiscoveryMode.Scan:
AddressRanges = NetworkInformationEx.GetAllNetInterfaces(NetworkClass)
.Select(t => new AddressRange(t, false)).Distinct();
break;
default:
AddressRanges = Enumerable.Empty <AddressRange>();
break;
}
}
request.Configuration.AddressRangesToScan = AddressRange.Format(AddressRanges);
if (!string.IsNullOrEmpty(request.Configuration.PortRangesToScan))
{
if (PortRange.TryParse(request.Configuration.PortRangesToScan,
out var ports))
{
PortRanges = ports;
}
}
if (PortRanges == null)
{
switch (request.Discovery)
{
case DiscoveryMode.Local:
PortRanges = PortRange.All;
break;
case DiscoveryMode.Fast:
PortRanges = PortRange.WellKnown;
break;
case DiscoveryMode.Scan:
PortRanges = PortRange.Unassigned;
break;
case DiscoveryMode.Off:
PortRanges = Enumerable.Empty <PortRange>();
break;
default:
PortRanges = PortRange.OpcUa;
break;
}
}
request.Configuration.PortRangesToScan = PortRange.Format(PortRanges);
request.Configuration.IdleTimeBetweenScans ??= kDefaultIdleTime;
request.Configuration.PortProbeTimeout ??= kDefaultPortProbeTimeout;
request.Configuration.NetworkProbeTimeout ??= kDefaultNetworkProbeTimeout;
TotalAddresses = AddressRanges?.Sum(r => r.Count) ?? 0;
TotalPorts = PortRanges?.Sum(r => r.Count) ?? 0;
}
public void TestParsing7()
{
PortRange.TryParse("*-100", out var range1);
Assert.Single(range1);
Assert.Equal(new PortRange(0, 100), range1.Single());
}
public void TestParsing6()
{
PortRange.TryParse("100-*", out var range1);
Assert.Single(range1);
Assert.Equal(new PortRange(100, 65536), range1.Single());
}
public MemoryFirewallRuleRanges(List <IPAddressRange> ipRanges, List <PortRange> allowedPorts, bool block)
{
allowedPorts = (allowedPorts ?? new List <PortRange>(0));
foreach (IPAddressRange range in ipRanges)
{
// optimized storage, no pointers or other overhead
if (range.Begin.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
uint begin = range.Begin.ToUInt32();
uint end = range.End.ToUInt32();
Debug.Assert(end >= begin);
ipv4.Add(new IPV4Range {
Begin = begin, End = end
});
}
else
{
UInt128 begin = range.Begin.ToUInt128();
UInt128 end = range.End.ToUInt128();
Debug.Assert(end.CompareTo(begin) >= 0);
ipv6.Add(new IPV6Range {
Begin = begin, End = end
});
}
}
ipv4.TrimExcess();
ipv6.TrimExcess();
if (block)
{
string portString = IPBanFirewallUtility.GetPortRangeStringBlockExcept(allowedPorts);
this.portRanges = (string.IsNullOrWhiteSpace(portString) ? new List <PortRange>(0) : portString.Split(',').Select(s => PortRange.Parse(s)).ToList());
}
else
{
this.portRanges = allowedPorts;
}
}
