...is hard. It's one thing to learn how to do simple math equations to figure out how many hosts can be on a network or to covert CIDR notation to a quad-dotted submask, but it's completely another thing to write an application in a language you barely speak—especially when this application needs 100% accuracy.
I'm going to give a quick run over of what and why I did it. It'll probably sound way more complicated than it really is.
from the top
I'd first like to mention that my code sucks. Like, sucks bad. It's full of anonymous functions calling themselves immediately after they finish, and the whole thing is around 250 lines when it could easily be around 100. But it works, and the cleaning will come later.
I started by listing all potential submask values. I made a list where I have all values from
255.255.255.255, and each value is inside an
if statement. Now, this will change in the future when I made it into a
for loop and an array of data, but until then
if the user inputs a particular submask or /CIDR then it'll write both to the screen.
Next I figure out how many hosts the network can hold with this equation:
That basically says
if the CIDR number is greater than zero then take 2, raise it to the power of 32 minus the CIDR number, then subtract two. I subtract the CIDR number from 32 because the CIDR describes the "ON" bits, while the possible hosts are located in the "OFF" bits. Since there's 32 possible bits, I invert the bits by taking the "ON" from the total.
This is fairly straight forward. I take the IP the user provides me, split it up into separate parts on the decimals, and store it in an array. I then take the first value in the array and compare it to a set of
if statements. If the IP value falls within a certain range, then the corresponding class will be written to the screen.
the hard part
If I was writing this in C or Python there are packages I could use to convert an
int -> bin. Then I could use basic functions to do some math, then convert the
parseInt(string, radix).toString(base). That sucks. It's saying to parse this string as an integer with the radix you pass it, then convert that to a string with whatever base you specified.
It doesn't work very well, especially when you're doing some math while trying to convert the specific values you want to binary. Instead of doing that, I decided to do a slightly more rudimentary method.
What I do is pretend I'm using binary, but use the CIDR number instead. Since the CIDR denotes the "ON" bits, and we know there's 32 bits total, the CIDR will tell us how many octets are filled with "ON" bits. Each bit inside an octet's value will be, from right to left, 1, 2, 4, 8, 16, 32, 64, and 128.
%). It works like the division sign, but instead of returning how many times the divisor goes into the dividend, it returns what's left over after you evenly divide the numbers.
10 % 8 will return
142 % 1 = 0.
10 % 3 = 1.
If we take the CIDR number % 8, it'll tell us how many "ON" bits are left over after we get past all the filled octets. Once we've determined that number, we'll have to figure out how to make it usable.
Even though we know the bits values and the number of bits, everything's backwards. In order to save ourselves from writing unnecessary code (lol), we'll do something like this:
The number we're looking for is 'baz'. The number we got from the modulo is 'bar'. 'Foo' is going to be the middle number—the one we use to do some fun math.
If we subtract our modulo from 8, we get the opposite side of the spectrum. We then need to get the correct bit value, which will be 2 to the power of the bit position. This will give us the bit value we want, which in turn lets us figure out the network ID.
If you're doing everything by hand, usually you'd add the bit value to itself until it's less than or equal to the respective IP segment (e.g. /8 would the third IP segment, a /4 the second, and so on). But we can do that without using any loops. Just take the IP segment's value, divide it by the bit value, use
Math.floor in order to ignore the remainder, and then we can multiply that value by the bit value. This will give us the max value we can use without going into a new network. The broadcast bit value is one less than the network bit value.
The maximum subnets a submask can be described like this:
r is the CIDR number and
n is the number of full octets. And that's about it.
all together now