/// <summary> Populates this IP_Restriction range information with all of the IP Restriction ranges for this library </summary>
/// <param name="All_Ranges"> DataTable containing all of the IP ranges </param>
public void Populate_IP_Ranges(DataTable All_Ranges)
{
lock (thisLock)
{
DataColumn startColumn = All_Ranges.Columns["StartIP"];
DataColumn endColumn = All_Ranges.Columns["EndIP"];
rangeDictionary.Clear();
IpRanges.Clear();
IP_Restriction_Range currentRange = null;
foreach (DataRow thisRow in All_Ranges.Rows)
{
// Check if this is the same range, or add a new one
int ipRangeId = Convert.ToInt32(thisRow[1]);
if ((currentRange == null) || (currentRange.RangeID != ipRangeId))
{
currentRange = new IP_Restriction_Range(ipRangeId, thisRow[0].ToString(), thisRow[2].ToString(), thisRow[5].ToString());
IpRanges.Add(currentRange);
rangeDictionary[currentRange.RangeID] = currentRange;
}
// Add all the IP addresses to this
string start = thisRow[startColumn].ToString().Trim();
if (start.Length > 0)
{
currentRange.Add_IP_Address(start, thisRow[endColumn].ToString().Trim());
}
}
}
}
public void HowManyAvailable_ReturnsCountInRange_LessBlocks()
{
var sut = new IpRanges();
sut.Block(new Range(2, 5));
Assert.Equal(4294967292, sut.HowManyAvailable);
}
private void AddIpRange()
{
const byte maxIpRanges = byte.MaxValue;
if (IpRanges.Count < maxIpRanges)
{
IpRanges.Add(new IpRangeViewModel());
}
}
public void ReturnsNumbersStartingAt0_WhenIpRange_IsEmpty()
{
var expected = new Range(0, 4294967295);
var sut = new IpRanges();
var actual = sut.Lowest();
Assert.Equal(expected, actual);
}
public void ReturnsValues_Exclusive_OfRange()
{
var expected = new[] { new Range(0, 1), new Range(5, 4294967295) };
var sut = new IpRanges();
sut.Block(new Range(2, 4));
var actual = sut.AvailableRanges();
Assert.Equal(expected, actual);
}
private void RemoveIpRange(object obj)
{
if (IpRanges.Count <= 1)
{
_dialogCoordinator.ShowMessageAsync(this, "Oops..", "You can't remove the last ip range.");
return;
}
var ipRange = (IpRangeViewModel)obj;
IpRanges.Remove(ipRange);
}
public ContestSettings CreateSettings(IContestInformation contest)
{
var defaultCat = RegisterCategory?
.Where(k => k.Value != 0)
.ToDictionary(k => k.Key, v => v.Value);
if (defaultCat?.Count == 0)
{
defaultCat = null;
}
if (RestrictToIpRanges)
{
IpRanges ??= string.Empty;
}
else
{
IpRanges = null;
}
int restriction =
(RestrictToIpRanges ? 1 : 0)
| (RestrictToMinimalSite ? 2 : 0)
| (RestrictToLastLoginIp ? 4 : 0);
var penaltyTime =
contest.RankingStrategy == CcsDefaults.RuleXCPC &&
PenaltyTime != 20
? PenaltyTime : default(int?);
var scoreboardPagingEnabled =
UseScoreboardPaging switch
{
1 => true,
2 => false,
_ => default(bool?),
};
var settings = contest.Settings.Clone();
settings.BalloonAvailable = contest.Kind == CcsDefaults.KindDom && UseBalloon;
settings.EventAvailable = contest.Kind == CcsDefaults.KindDom && UseEvents;
settings.Languages = Languages;
settings.PrintingAvailable = contest.Kind == CcsDefaults.KindDom && UsePrintings;
settings.RegisterCategory = defaultCat;
settings.StatusAvailable = StatusAvailable;
settings.PenaltyTime = penaltyTime;
settings.ScoreboardPaging = scoreboardPagingEnabled;
settings.PreferGymUI = contest.Kind == CcsDefaults.KindDom && PreferGymUI ? true : default(bool?);
settings.RestrictIp = contest.Kind != CcsDefaults.KindDom || restriction == 0 ? default(int?) : restriction;
settings.IpRanges = IpRanges?.Split(';', StringSplitOptions.RemoveEmptyEntries);
return(settings);
}
public void HowManyAvailable_ReturnsCountInRange_LessAllBlocks()
{
var expectedAvailable = new[] { new Range(3, 3), new Range(9, 9) };
var sut = new IpRanges(9);
sut.Block(new Range(5, 8));
sut.Block(new Range(0, 2));
sut.Block(new Range(4, 7));
Assert.Equal(2, sut.HowManyAvailable);
Assert.Equal(8, sut.HowManyBlocked);
Assert.Equal(expectedAvailable, sut.AvailableRanges());
}
public void ReturnsValues_AfterMultipleOverlappedHaveToMerge()
{
var expected = new[] { new Range(0, 0), new Range(9, 4294967295) };
var sut = new IpRanges();
sut.Block(new Range(2, 4));
sut.Block(new Range(5, 8));
sut.Block(new Range(1, 7));
var actual = sut.AvailableRanges();
Assert.Equal(expected, actual);
}
public static void Problem20()
{
var ips = new IpRanges();
foreach (var range in FileStringReader.Read("P20.txt"))
{
ips.Block(Range.From(range));
}
ips.AvailableRanges().ToList().ForEach(a => Console.WriteLine(string.Format("{0} == {1}", a, a.HowManyInRange)));
Console.WriteLine("\nLowest Available = {0}", ips.Lowest());
Console.WriteLine("Number Blocked = {0}", ips.HowManyBlocked);
Console.WriteLine("Number Available = {0}", ips.HowManyAvailable);
}
/// <summary> Gets the bitwise mask of IP restrictive ranges to which this IP address belongs </summary>
/// <param name="IP_Address"> IP Address to verify against all IP restrictive ranges </param>
/// <returns>Restrictive ranges to which this IP address belongs, as a bitwise mask </returns>
public int Restrictive_Range_Membership(string IP_Address)
{
lock (thisLock)
{
int returnMask = 0;
// Split the IP address
string[] ipSplitString = IP_Address.Split(new[] { '.' });
// Currently only support IP 4
if (ipSplitString.Length == 4)
{
// Get the IP address as an unsigned integer
uint ipAsNumber = (Convert.ToUInt32(ipSplitString[0]) * 169476096) + (Convert.ToUInt32(ipSplitString[1]) * 65536) + (Convert.ToUInt32(ipSplitString[2]) * 256) + Convert.ToUInt32(ipSplitString[3]);
byte firstIpByte = Convert.ToByte(ipSplitString[0]);
// Step through each IP Restrictive range
returnMask += IpRanges.Where(ThisRange => ThisRange.Contains(ipAsNumber, firstIpByte)).Sum(ThisRange => (int)Math.Pow(2, ThisRange.RangeID - 1));
}
return(returnMask);
}
}
public virtual bool IsInIpRange(string ip)
{
return(IpRanges.Count == 0 || IpRanges.Cast <IpRange>().Any(ipRange => ipRange.IsInRange(ip)));
}
