subnetCalculator.cpp - Subnet Calculator Example

/**
 * [subnetCalculator.cpp]
 *
 * Subnet Calculator example.
 *
 * by Rocco Castoro.
 */
#include "subnetCalculator.hpp"

/**
 * The main() function:
 */
int main(void)
{
    /**
     * Give details, given an IP and Subnet Mask:
     */
    char        resp = 'y';

        while(resp == 'y')
        {
            cout << " //// -- IPv4 Subnetting Calculator -- \\\\\\\\" << endl;
            cout << "||||  ----- dev. by Rocco Castoro ----- ||||" << endl;
            cout << " \\\\\\\\ ----- rockycast@hotmail.com ----- ////" << endl;
            cout << endl << endl;


            /**
             * Get IP address octets:
             */
            string      ip;
            vector<int> octetsIP;

                while(getOctetsIP(ip, octetsIP) == 1)
                {
                    cout << "Enter IPv4 address -> ";

                    (getline(cin, ip));                     // Accept user input for IP address.
                }


            /**
             * Get subnet mask octets:
             */
            string      mask;
            vector<int> octetsMask;

                while(getOctetsMask(mask, octetsMask) == 1)
                {
                    cout << "Enter subnet mask for " << ip << " -> ";

                    (getline(cin, mask));                   // Accept user input for subnet mask.
                }

            cout << endl << endl << endl << endl << endl;


            /**
             * Print Initial User IP and Subnet Mask:
             */
            vector<int> decimals;

            cout << "//////////////////////////////////////////" << endl;
            cout << "/// IP Address: " << toString(octetsIP) << endl;

            vector<int> decimalMask = toDecimal(octetsMask, decimals);

            cout << "/// Subnet Mask: " << toString(octetsMask) << endl;
            cout << "//////////////////////////////////////////" << endl << endl;


            /**
             * Print Binary Representation:
             */
            vector<int> octetsIPBits;
            vector<int> octetsMaskBits;

            getNHBits(octetsIP, octetsMask, octetsIPBits, octetsMaskBits);

            vector<int> netID = getNetID(octetsIP, octetsMask);
            vector<int> decimalNetID = toDecimal(netID, decimals);

            int         netInc = getIncrement(decimalMask, decimalNetID);

            cout << endl;


            /**
             * Print IP Class:
             *
             * Run function to determine and print IP class.
             */
            cout << "------------------------------------------" << endl;
            cout << "//////////// Class Information ///////////" << endl;
            cout << "------------------------------------------" << endl;

            int         classResult = calcClass(octetsIP);
            int         ipClass = 0;

                switch(classResult)
                {
                    case 1:
                        cout << "IP Class: Private block, Class 'A' " << endl;

                        ipClass = 1;
                        break;
                    case 2:
                        cout << "IP Class: Private block, Class 'B' " << endl;

                        ipClass = 2;
                        break;
                    case 3:
                        cout << "IP Class: Private block, Class 'C' " << endl;

                        ipClass = 3;
                        break;
                    case 4:
                        cout << "IP Class: Reserved block, System Loopback Address" << endl;

                        ipClass = 1;
                        break;
                    case 5:
                        cout << "IP Class: A" << endl;

                        ipClass = 1;
                        break;
                    case 6:
                        cout << "IP Class: B" << endl;

                        ipClass = 2;
                        break;
                    case 7:
                        cout << "IP Class: C" << endl;

                        ipClass = 3;
                        break;
                    case 8:
                        cout << "IP Class: D" << endl;

                        ipClass = 4;

                        cout << "!! This is a reserved Class D Multicast IP Address Block" << endl;
                        break;
                    case 9:
                        cout << "IP Class: E" << endl;

                        ipClass = 5;

                        cout << "!! This is a reserved Class E Multicast IP Address Block" << endl;
                        break;
                    default:
                        cout << "Not in Range" << endl;
                        break;
                }

            vector<int> subClassMask;

            getSubnets(decimalMask, ipClass, subClassMask);

            cout << "Default Class Subnet Mask: " << toString(subClassMask) << endl;
            cout << "------------------------------------------" << endl << endl;


            /**
             * Print Subnetting Details:
             */
            cout << "------------------------------------------" << endl;
            cout << "///////////// Subnet Details /////////////" << endl;
            cout << "------------------------------------------" << endl;

            vector<int> netIDRange = getNetIDRange(decimalNetID, netInc, decimalMask);

            cout << "Network ID:            -           Broadcast ID: " << endl;
            cout << "------------------------------------------" << endl;
            cout << toString(netID) << " - [ usable hosts ] - ";
            cout << toString(netIDRange) << endl << endl;
            cout << "Network Increment: " << getIncrement(decimalMask, decimalNetID) << endl;
            cout << "Number of Subnets: " << getSubnets(decimalMask, ipClass, subClassMask) << endl;
            cout << "Usable hosts per subnet: " << getHostsPerSubnet(decimalMask) << endl;
            cout << "------------------------------------------" << endl << endl;

            cout << "Would you like to enter another IP Address to subnet? (y or n): ";
            cin >> resp;
            cout << endl << endl << endl << endl;
        }

    return 0;
}