/// <summary>
/// Returns the next subnet in the sequence
/// </summary>
/// <returns></returns>
public Subnetwork NextSubnet()
{
// Will be returned to the network buidler class
Subnetwork ReturnNetwork = new Subnetwork();
byte[] BaseAddress = _SampleAddress.AddressArray;
// Calculate the nessecary information to build the IPs on the subnet
byte lastUsable = Convert.ToByte(_HostsPerSubnet * _SubnetNumber - 2);
byte broadCastAddress = Convert.ToByte(lastUsable + 1);
// HORRID HACK
// I am Elijah Ellis Please remember my name as I may not
// The subnet ID here is a special case because it requires math using subtraction
byte subnetId;
if (_SubnetNumber == 1)
{
// I am sorry mom
subnetId = 0;
}
else
{
subnetId = Convert.ToByte(Math.Abs(_HostsPerSubnet - broadCastAddress - 1));
}
byte firstUsable = Convert.ToByte(subnetId + 1);
// TODO: Possibly refactor this section by using the BaseAddress away, but I am scared that it might mutate the contents of the array inproperly
// Build Subnet ID and attach it to the return network
byte[] NetworkIdArray = BaseAddress;
NetworkIdArray[3] = subnetId;
IpAddress NetworkID = new IpAddress(NetworkIdArray);
ReturnNetwork.NetworkId = NetworkID;
// Build Broadcast address object
byte[] BroadCastAddressArray = BaseAddress;
BroadCastAddressArray[3] = broadCastAddress;
IpAddress BroadcastAddress = new IpAddress(BroadCastAddressArray);
ReturnNetwork.BroadcastAddress = BroadcastAddress;
// Build the first usuable
byte[] FirstUsuableArray = BaseAddress;
FirstUsuableArray[3] = firstUsable;
IpAddress FirstUsable = new IpAddress(FirstUsuableArray);
ReturnNetwork.FirstUsable = FirstUsable;
// Built the last usable address object
byte[] LastUsuableArray = BaseAddress;
LastUsuableArray[3] = lastUsable;
IpAddress LastUsable = new IpAddress(LastUsuableArray);
ReturnNetwork.LastUsable = LastUsable;
// Increment the subnet number for the next calculation
_SubnetNumber += 1;
return ReturnNetwork;
}
public NetworkBuilder(NetworkInfo Info)
{
//// Get the nessecary data to build the subnetting information
//int NumberOfHostsNeeded = Info.NumberOfHosts;
//// The nessecary address class for the number of subnets and the required hosts per subnet
//AddressClass InetClass = DetermineNessecaryAddressClass(NumberOfHostsNeeded);
//// Uses 2^x to determine how many bits need to be borrowed
//int BitsToBorrow = DetermineBitsToBorrow(NumberOfHostsNeeded, InetClass);
//int BitsForAddressSpace = DetermineBitsForAddressSpace(BitsToBorrow, InetClass);
//int RequiredSubnets = DetermineNumberOfSubnets(BitsToBorrow, InetClass);
int BitsToBorrow = DetermineBitsToBorrow(Info.RequiredSubnets);
AddressClass InetClass = DetermineNessecaryAddressClass(Info.NumberOfHosts);
int AddressSpaceBits = DetermineBitsForAddressSpace(BitsToBorrow, InetClass);
int RequiredSubnets = IntPow(2, BitsToBorrow);
// Gets the subnet mask using data resources basedo n the required bits to borrow
SubnetMask NetMask = GetSubnetAddress(InetClass, BitsToBorrow, AddressSpaceBits);
IpAddress SampleAddress = new IpAddress(Info.SampleAddress);
// The program has different functionallity based on different address class
// For Class C it will be able to build the entire subnet out
// For the other classes it will display generic subnetting information but not build a subnet
switch (InetClass)
{
case AddressClass.A:
BuiltNetwork = new FullNetwork();
// Gather network information for Class A
//ClassAandBBuilder ClassABuilder = new ClassAandBBuilder();
//ClassABuilder.NetMask = NetMask;
//ClassABuilder.HostsPerSubnet = IntPow(2, (AddressSpaceBits - 2) );
//ClassABuilder.NumberOfSubents = IntPow(2, BitsToBorrow);
//BuiltNetwork.ClassAorBBuilder = ClassABuilder;
BuiltNetwork = new FullNetwork();
BuiltNetwork.BitsBorrowed = BitsToBorrow;
BuiltNetwork.Class = InetClass;
BuiltNetwork.NetMask = NetMask;
BuiltNetwork.NumberOfSubnets = IntPow(2, BitsToBorrow);
BuiltNetwork.AddressSpace = IntPow(2, AddressSpaceBits);
BuiltNetwork.UsableHosts = IntPow(2, AddressSpaceBits) - 2;
break;
case AddressClass.B:
//BuiltNetwork = new FullNetwork();
//ClassAandBBuilder ClassBBuilder = new ClassAandBBuilder();
//ClassBBuilder.NetMask = NetMask;
//ClassBBuilder.HostsPerSubnet = IntPow(2, AddressSpaceBits);
//ClassBBuilder.NumberOfSubents = IntPow(2, BitsToBorrow);
//BuiltNetwork.ClassAorBBuilder = ClassBBuilder;
BuiltNetwork = new FullNetwork();
BuiltNetwork.BitsBorrowed = BitsToBorrow;
BuiltNetwork.Class = InetClass;
BuiltNetwork.NetMask = NetMask;
BuiltNetwork.NumberOfSubnets = IntPow(2, BitsToBorrow);
BuiltNetwork.AddressSpace = IntPow(2, AddressSpaceBits);
BuiltNetwork.UsableHosts = IntPow(2, AddressSpaceBits) - 2;
break;
case AddressClass.C:
// Gather network information for Class C
int SubnetCount = 0;
BuiltNetwork = new FullNetwork();
// Begin the subnet building process
ClassCSubnetBuilder ClassCBuilder = new ClassCSubnetBuilder(NetMask, SampleAddress);
// Subtraction by one because it is a based of zero
while (SubnetCount < RequiredSubnets)
{
SubnetCount += 1;
Subnetwork Subnet = ClassCBuilder.NextSubnet();
BuiltNetwork.Subnets.Enqueue(Subnet);
}
BuiltNetwork.BitsBorrowed = BitsToBorrow;
BuiltNetwork.Class = InetClass;
BuiltNetwork.NetMask = NetMask;
BuiltNetwork.NumberOfSubnets = IntPow(2, BitsToBorrow);
BuiltNetwork.AddressSpace = (IntPow(2, AddressSpaceBits) * BuiltNetwork.NumberOfSubnets);
BuiltNetwork.UsableHosts = IntPow(2, AddressSpaceBits) - 2;
break;
default:
break;
}
}
/// <summary>
/// Returns the next subnet in the sequence
/// </summary>
/// <returns></returns>
public Subnetwork NextSubnet()
{
// Will be returned to the network buidler class
Subnetwork ReturnNetwork = new Subnetwork();
byte[] BaseAddress = _SampleAddress.AddressArray;
// Calculate the nessecary information to build the IPs on the subnet
byte lastUsable = Convert.ToByte(_HostsPerSubnet * _SubnetNumber - 2);
byte broadCastAddress = Convert.ToByte(lastUsable + 1);
// HORRID HACK
// I am Elijah Ellis Please remember my name as I may not
// The subnet ID here is a special case because it requires math using subtraction
byte subnetId;
if (_SubnetNumber == 1)
{
// I am sorry mom
subnetId = 0;
}
else
{
subnetId = Convert.ToByte(Math.Abs(_HostsPerSubnet - broadCastAddress - 1));
}
byte firstUsable = Convert.ToByte(subnetId + 1);
// TODO: Possibly refactor this section by using the BaseAddress away, but I am scared that it might mutate the contents of the array inproperly
// Build Subnet ID and attach it to the return network
byte[] NetworkIdArray = BaseAddress;
NetworkIdArray[3] = subnetId;
IpAddress NetworkID = new IpAddress(NetworkIdArray);
ReturnNetwork.NetworkId = NetworkID;
// Build Broadcast address object
byte[] BroadCastAddressArray = BaseAddress;
BroadCastAddressArray[3] = broadCastAddress;
IpAddress BroadcastAddress = new IpAddress(BroadCastAddressArray);
ReturnNetwork.BroadcastAddress = BroadcastAddress;
// Build the first usuable
byte[] FirstUsuableArray = BaseAddress;
FirstUsuableArray[3] = firstUsable;
IpAddress FirstUsable = new IpAddress(FirstUsuableArray);
ReturnNetwork.FirstUsable = FirstUsable;
// Built the last usable address object
byte[] LastUsuableArray = BaseAddress;
LastUsuableArray[3] = lastUsable;
IpAddress LastUsable = new IpAddress(LastUsuableArray);
ReturnNetwork.LastUsable = LastUsable;
// Increment the subnet number for the next calculation
_SubnetNumber += 1;
return(ReturnNetwork);
}
