IP Address History

RFCs

What I found is that if you understand the history of IP addressing, then you can better understand where we are at, why subnetting exists, and how we can implement subnetting.

There are a lot of different standards out there, and a lot of protocols out there. Some of them are proprietary, which means that they're owned by a company, and that company then creates these rules on how things should operate. But a lot of them are open standards out there that are defined so that anybody can access them. So how do you figure out what these open standards are that are out there? How are they published? They are published through these RFCs.

What will happen is there'll be some sort of need out there, and maybe an individual, maybe an engineer, maybe a company, maybe it's a task force, a committee — somebody gets together and determines what the standard should be to implement out there and how everything should operate. Then they'll put out one of these RFCs. The RFC, request for comments, will be put out there with a description of exactly what they're trying to solve, how they're trying to solve it, and what the standard is that everybody should fall into. Then what will happen is these will develop over time, so a new one will come out and supersede or take over one of the prior ones and make one of the older ones obsolete.

So these RFCs are a great wealth of information. It shows a bit of history of where we come from and where we're going, and these are great when you have certain questions. I find that there's a lot of misinformation out there on the internet, or a little bit of misleading information out there on the internet. So what's really helpful is to go back to these RFCs and read them and find out: is it really true? Because this is the source for a lot of different protocols and a lot of different standards that are out there.

What a Network Means

Network is one of those terms that we kind of throw around, and it can mean several different things. So let's define first of all what a network means when it comes to IP addressing. When we're talking about IP addressing, a network is a local area network, or a local set of devices that are connected together.

The whole picture here could be considered a network, but from an IP address standpoint, there are lots of networks in here. There is a network over here — this is a network of local computers and devices that are plugged in together, that are directly connected on the same network together. This is a network over here, and I don't want to get too involved into it, but these are networks between these devices right here. So when I say network, these are the local networks there.

Largely what we're going to be talking about is how, when we broke apart the IP address into the network portion, that represents this right here and this is a network, and then each one of these on this network is a host.

Earlier iterations of IP version 4 and how it was constructed really didn't leave a lot of networks out there, and had a ton of hosts per network. This caused problems, and is the reason why we had to continue to change things: to increase the number of networks there are, and we didn't need as many hosts on these networks. So keep that in mind as we go along.

A Timeline of IP Addressing

One thing to understand is that IP addresses have been around for a long time. They've been used to communicate between devices on the network for quite a while. But we're going to start our journey in 1980 with RFC 760, where an IP address was defined that's very similar to the IP addresses that we see now. Although it was very limiting in its scope and what it could provide, and it was very quickly determined that we were going to grow beyond what RFC 760 addresses. So they needed to do something quickly.

So in 1981 they developed this concept of classes. RFC 791 defines what different classes there are and how to break apart these IP addresses into smaller pieces.

Shortly after that they still saw a need — these classful addresses don't really break it up all that well. So let's create subnets, where you're breaking classful addresses down into subnets. That happened in 1985 with RFC 950.

Then we've got a little bit of a break. Things were still in development. I've got my next point on my timeline here at 1995. But this idea of VLSM and CIDR, and a few other concepts, classless, actually came before this, in like 1993. But in 1995 RFC 1878 came out defining VLSM. VLSM allows us to break out networks into even smaller chunks, and variable chunks really.

Then they still have a need. So in 1996 RFC 1918 came out. It wasn't the first RFC to define private addressing, but it's the one that we use today. This came out in 1996, and we started utilizing heavily into this private addressing.

Still saw a need. We're still realizing we're going to outgrow this. We need a long-term solution. And that's where IP version 6 came out. IP version 6 came out in 1998 with RFC 2460.

This gives you kind of an overview of how we created a standard, realized that we were going to become outdated, and then how to create a new standard to cope with the growing needs of these networks — the internet was really taking off, and just the craziness that happened with the amount of networks that we needed to be able to facilitate, the number of computers and the number of networks that were growing on these networks.

RFC 760

RFC 760 is a good starting point because we do see that this IP address looks very similar to the IP address that we have now. But the difference with RFC 760, one of the first iterations of IP addresses, is that it defined that the first octet is going to be the network. So this octet right here defines the network. What that means is there's only eight bits devoted towards a network. So if you only have eight bits devoted towards a network, that means the max number of networks that you can have is 256. It's 2 to the 8th power. That is 256 possibilities. So this only allows for 256 networks. That's obviously a problem.

RFC 791 and Classful Addressing

Quickly they realized that since this is a problem, let us come up with a solution. That's where RFC 791 came about. The idea behind RFC 791, or classful addresses, is that we start breaking down these IP addresses into classful ranges, and they break it down into a class A, a class B, a class C.

What it does is it says that for a class A we're going to devote this to being a network address, which gives us 128 networks and over 16 million nodes or hosts per network. If it's a class B, then it's going to be the first two octets, which gives us over 16,000 networks and 65,000 hosts per network. If it's a class C, then you're going to use three octets, and that gives us over two million networks and close to 256 hosts per network.

So if you add that all up together, we're in the millions from a network standpoint. This allows us to stretch this out and be able to do a little more with these networks. I have a lot more networks, over two million networks out there with this structure, with this classful structure. So we operated a while on these classful addresses.

RFC 950 and Subnetting

Since we needed more networks, we came up with subnetting, RFC 950. The idea behind subnetting is that you still work within those classful ranges, but you can break them down even further.

A couple of problems that this is solving. Number one is that with over two million networks we still didn't have enough networks. The networks continued to grow, and the amount of connectivity on the internet and all these networks that were connecting were still continuing to grow. So we needed more networks. The other thing is that the number of nodes per network — 16 million nodes per network is just really unreasonable. We didn't need that many nodes. You couldn't have that many nodes on a single network.

So what subnetting is, let's say a class A for example. Subnetting allows us to still stay somewhat in the confines of subnetting, but allows us to draw a line somewhere in here and say these are all the network bits now and these are all of the host bits. Which allows us to really get more granular with how many networks we have and how many hosts that we have. So now we're able to break apart and have more networks and less hosts per network, and be able to drastically increase the number of networks that we have now.

VLSM, CIDR and Classless

Between 1993 and 1995 we had these concepts of VLSM, CIDR and classless come out in the form of several different RFCs: RFC 1518, 1519, 1817, 1860 and 1878. Some of them were different iterations, some were slightly different concepts, so they didn't take the place of the earlier iteration. But essentially what we can think of this as is doing away with the classful addresses. We still function, even now we still function to a certain degree within these classful addresses. But the idea is that we do away for the most part with these classes that we have, and really are able to draw the line wherever we want to create different sized networks.

And so the big difference between this and subnetting is that with subnetting, if we had a class A, that was the default network right there, but then we would draw the line over here somewhere over here — subnetting is where we draw a single line and then all of the networks had to conform to that same subnet. Whereas variable length subnet mask means that every single network could draw the line in a different spot, as long as the networks weren't overlapping.

There's a lot more to it than that, and I understand that that probably doesn't give you the full picture. But this gives you a concept of what variable length subnet mask is. We can draw that line anywhere to denote what is the network side of this and what is the host side of it.

Private Addressing

Once again we still realize we're still lacking some addresses and some networks. We're still growing. We need to adapt to this. And then that's when private addressing came out. RFC 1597, 1627 and 1918 all define aspects of it. They're all different iterations of this, but the one that you're most concerned with is the current one, which is 1918. You will see that on different exams that are out there, and you'll run across it. So if you see RFC 1918, think private addressing. You will need to remember that.

So RFC 1918, or private addressing — what it is, is it allows some overlapping of IP addresses. What that means is that up until now you could never have any overlapping addresses. You could never have two machines out there in the world that had the same IP address, because what would happen is it would be confusing on which device do I route traffic to? I don't know if they have the same IP address.

What this allows is for you to have, on your network, some sort of private address that you use within your network, but that is never exposed to the outside world. And it gets translated at some sort of gateway, translated into an address that can be used to the outside world. Therefore, if you had hundreds of machines inside your network, maybe you just had a few of these public IP addresses that you could use going out into the world.

Private addressing sets aside these ranges for each one of the classes. So here's the class A range, here's the class B range, and the class C range. It sets these aside for you to utilize within your private addresses. So if you go to your work network, if you go to your home network and you take a look at the addressing that you have on there, it's probably a private address. And other devices, lots of other devices have that same address out there in the world. But once you go out to the internet, you can't have those private addresses out there on the internet. So what happens is it translates it to some sort of IP address that your internet service provider gives you, so you can go out there and get resources out on the internet.

Here's what that looks like as a topology. Maybe you have an internal machine right here and it's using 10.0.0.4. Maybe it's talking to five. So internally, you're just using this 10 range to talk to all devices on there. No overlaps within your network. You don't want the same IP address assigned to two different devices on your network. There are a couple of exceptions to that when you're dealing with load balancing, but that is a whole other topic. For the most part, really, you don't want, you really can't have overlapping IP addresses on your network. But then as it goes to the outside world, maybe it picks up a private address, or a 41. So then that's what the rest of the world sees, and they never see your internal address here.

IP Version 6

There was still this idea though that we're going to still run out at some point in time. So ever since then, we've been trying to develop IP version 6 and get IP version 6 rolled out. In which case, for IP version 4 you have 10 to the 32nd power. You have 32 bits. So 10 to the 32nd power gives you a little over 4 billion different addresses. So a lot, but we use a lot of those. And there's still a little bit of waste that's out there as well.

Then you've got IP version 6, and IP version 6 is 10 to the 128th power. They really said, what can we possibly imagine that we're going to need for the foreseeable future? And let's go way above and beyond that. And the number of IP addresses that we have is so much incredibly larger than what IP version 4 has that I don't even know when you get to that level what that's called at that level, but it is a lot more possibilities, a lot more addresses that you can have out there.

The History in Review

So there's the history of IP addresses. We start out with RFC 760 — or at least in our story we started out with RFC 760 — where we have just the first octet defining the network, limiting us only to 256 networks, and we can have millions of nodes on that network. But 256 networks was really limiting. So we developed this classful system, or classes, in 1981 with RFC 791 to break this thing down further, to break it into classes and what those classes look like, so that way we can get more networks. Still it's not enough. So we come up with subnets on how we can break that down even further. So we get away to a certain degree from those classes. And in 1995, with RFC 1878, VLSM comes out and really starts getting used, which allows us to really choose what subnet we have and get rid of that classful system pretty much altogether. And then we get into private addressing, where we are allowed some overlap.