private void DecimalIpAddressTextBox_KeyUp(object sender, KeyEventArgs e)
        {
            string RawInput;
            RawInput = DecimalIpAddressTextBox.Text.Trim();

            // CIDR regex
            string pattern = @"((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
            Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);

            if (rgx.IsMatch(RawInput) == true)
            {
                try
                {
                    IpAddress Address = new IpAddress(RawInput);
                    BinaryIpAddressTextBox.Text = Address.ToBinaryString();
                }
                catch (Exception)
                {

                    BinaryIpAddressTextBox.Text = "Invalid Address";
                }
            }
            else
            {
                BinaryIpAddressTextBox.Text = "";
            }
        }
 /// <summary>
 /// Initialization of the Class variable nessecary for building the subnet
 /// </summary>
 /// <param name="AddressClass"></param>
 /// <param name="SubnetNumber"></param>
 public ClassCSubnetBuilder(SubnetMask NetMask, IpAddress BaseAddress)
 {
     _SubnetNumber = 1;
     // We are casting to a byte here because for class A and class B the count will be greater than 255, but in every other case it will be <255
     _HostsPerSubnet = NetMask.UsableHostsPerSubnet;
     _SampleAddress = BaseAddress;
 }
        /// <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 IpAddress AndAddress(IpAddress Ip, SubnetMask Subnetmask)
        {
            AddressParser Parser = new AddressParser();
            byte[] AndedAddress = new byte[4];

            for (int i = 0; i < Ip.AddressArray.Length; i++)
            {
                AndedAddress[i] = (byte)(Ip.AddressArray[i] & Subnetmask.AddressArray[i]);
            }

            IpAddress ReturnAddress = new IpAddress(AndedAddress);
            return ReturnAddress;
        }
        private void AndValues_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                string IpAddressInput = IpAddressTextBox.Text;
                string SubnetmaskInput = SubnetMaskTextBox.Text;

                Ander AddressAnder = new Ander();

                IpAddress InputIpAddress = new IpAddress(IpAddressInput);
                SubnetMask InputNetmask = new SubnetMask(SubnetmaskInput);

                IpAddress AndedAddress = AddressAnder.AndAddress(InputIpAddress, InputNetmask);

                OutputTextBox.Text = AndedAddress.ToString();
            }
            catch (Exception)
            {
                Helpers.MessageBox MessageBox = new Helpers.MessageBox("Invalid input");
                MessageBox.Show();
            }
        }
        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;
            }
        }
 /* Private members */
 /// <summary>
 /// Initializes the base address
 /// </summary>
 /// <param name="baseAddress"></param>
 /// <returns></returns>
 private IpAddress ParseBaseAddress(IpAddress baseAddress)
 {
     throw new NotImplementedException();
 }
 // Test
 static void PrintAddressInformation(IpAddress ip)
 {
     Console.WriteLine(ip.Address);
     foreach (byte oct in ip.AddressArray)
     {
         Console.WriteLine(oct.ToString());
     }
 }
Exemple #9
0
        /// <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);
        }
Exemple #10
0
        /* Private members */

        /// <summary>
        /// Initializes the base address
        /// </summary>
        /// <param name="baseAddress"></param>
        /// <returns></returns>
        private IpAddress ParseBaseAddress(IpAddress baseAddress)
        {
            throw new NotImplementedException();
        }