Evolution of the Address Space
| IP and its addressing scheme evolved slowly, sometimes even erratically, over time. They were not, contrary to any current appearances, carefully designed prior to implementation! For example, RFC 1, published in April 1969, tells us that the original IP address space was specified at just 5 bits! As you will see in this chapter, that's enough for just 32 addresses! Strange as that might sound, in 1969 that was more than enough for the embedded base of computers that were being internetworked. Over time, the number of bits allocated to host addressing was increased to 6, and then 8, and finally up to the familiar 32-bit format that is in use today. The actual format of the "IP address" evolved slowly over time in response to the evolution of the DARPAnet. DARPAnet was the predecessor of the Internet. In essence, it was a network that interconnected various research facilities in support of the U.S. Department of Defense. The notion of classes of addresses, with each class offering a differing combination of bits allocated between network and host identification, was first described in RFC 791, published in September 1981. This RFC is the foundation of what has become Classical IP addressing. Although it is technically obsolete, Classical IP still offers a marvelous opportunity to understand the current state of IP addressing. The Mathematics of the IPv4 Address SpaceThe current version of the Internet Protocol is version 4, or IPv4. Discussing the mathematics of the current address space in a chapter titled "The Way It Was" might seem a bit odd. Yet the title isn't misleading nor the topic out of place. How the IPv4 address space is implemented has changed radically since its inception. We'll make more sense of that throughout this chapter. For now, just recognize that IPv4 is still the current version. It is just the old way of carving up the IPv4 address space that has passed into obsolescence. IP addresses are defined within a mathematical space that is 32 bits in length. Bit is an abbreviation of binary digit. It is the smallest unit of data, and it can have a value of either 0 or 1. Typically, a pattern of 8 bits is called a byte, although purists within the data communications and networking fields insist that 8 bits is an octet. In truth, this is only a semantic distinction, so use whatever term you are most familiar with. It's time for a quick mathematical sanity check. Each bit can represent one of two different values: 0 or 1. Thus, the absolute maximum number of unique addresses you can create with a 32-bit address is 2 to the 32nd power, or 4,294,967,295 addresses. That sounds like a lot of addresses. It truly was an inexhaustible supply back in the days when only a few hundred computers were sprinkled around the globe. That was the intent of the architects of IP and its address space: Devise a schema that would be scalable beyond the foreseeable future. However, in today's age of a microprocessor in every household appliance, 4 billion doesn't seem quite so large! There are more than 6 billion people on the earth, so the current address system doesn't even allow one address per person. The Internet Engineering Task Force (IETFthe caretakers of the Internet's technology base) sought to make the address space more usable in numerous ways. They recognized that even a Base10 number would not be conducive to human use of the address space, because it was too large. Base10 is the decimal number system; it uses ten different symbols to represent numbers that progress in multiples of 10. This is the number system that most humans consider native. Unfortunately, keeping track of numbers from 1 to over 4 billion just isn't practical for humans! Thus, additional steps were taken to develop a logical hierarchy:
These three tactics abetted the usability of the IP address space in different ways. The first two directly facilitated human usage. The last tactic was designed to make the address space more scalable in its application than usable to individual users. These tactics and their impacts on the IP address space are described further in the following sections. Making the Address Space Human-FriendlyMaking the IP address space human-friendly required the use of both a familiar number system and the smallest numbers possible. Addressing the first of these criteria, people think in terms of the Base10 number system, whereas computers are inherently binary. That is, computers process information using one of two possible states: either on/off or 1/0. Either way, information is encoded and processed by computers using very long strings that are made up of just two symbols. It would be well beyond the capability of any person to reliably recall the 32-bit address strings of binary numbers relied upon by computers and computer networks to communicate. The Internet's original address space was created to be inexhaustible so that the Internet's future growth would not be artificially constrained. Although that design criterion ensured a future for the Internet, it also created a more vexing problem. From a more pragmatic perspective, the raw address space was so large as to be unusable by humans. Again, most humans cannot reliably recall specific 32-bit strings of binary numbers. Converting any given 32-bit string of binary numbers into decimal numbers would, at least in theory, make the number more human-friendly. After all, the Base10 number system is so familiar to human beings as to be second nature. Unfortunately, a 32-bit binary number can potentially translate into a decimal number so large that it is almost meaningless to human beings. For example, imagine trying to remember whether your computer's address is 4,217,824,125 or 4,217,924,125. However, those numbers are easier to remember than their binary equivalents (which are 11111011011001101110001101111101 and 11111011011010000110101000011101, respectively, in the Base2 number system). Thus, you could successfully argue that using decimal numbers instead of binary numbers directly reduced the size of the "numbers" that people would have to remember. But they are still far too cumbersome to be useful. You would have great difficulty remembering your own IP address, much less trying to remember the IP addresses of useful destination machines. NOTE This discussion about the relative difficulty of remembering numeric IP addresses predates the use of mnemonics as a substitute for numeric addresses. Today's Internet users seldom directly use IP addresses for accessing information stored throughout the Net. The introduction of structured mnemonics for hosts and their domains has all but obviated the practice of using raw IP addresses. These technologies are explored in more detail in Chapter 8, "Internet Names." However, it is important to remember that the logistics of remembering and using large numbers factored into the design of the address space. Thus, the first priority in making the IP address space human-friendly was to provide a mathematical translation so that people could continue to use the Base10 number system that they are so familiar with! But that still left unsolved the tandem problems of remembering and using large numbers. The Purpose of the DotsAlthough it might seem counterintuitive, especially when we are accustomed to thinking in terms of only decimal numbers, the logical solution to the unmanageably large address space was to break it into a series of smaller numbers. To continue with the example used in the preceding section, a decimal value of 4,217,824,125 presents an interesting case study. Given that this number has four components (groups of billions, millions, thousands, and hundreds/tens/ones), it might seem logical to just split the number along those lines. But several potential problems emerge from such an arbitrary subdivision. The first potential problem is that such subdivision results in an asymmetric range of valid numbers for each group. The billions group would have a valid range of just 0 to 4, whereas the other three groups' valid ranges would be from 0 to 999. Such asymmetry isn't of great consequence, but it heralds a compromise in the original goal of absolutely minimizing valid numeric ranges. Rememberthe smaller the numbers, the easier they are to remember and use! The next concern is that this scheme is based on decimal numbers but the address space is inherently binary. The same is true of the computers that use the address space directly. Thus, it makes more sense to use binary numbers when evaluating potential techniques for using an address space. Given that the address space is 32 binary digits (bits) in length, segmenting this space is a logical means of creating more manageable numbers. The architects of the Internet's address space saw the wisdom in this approach. They disaggregated the 32-bit numeric address into four equal components of 8 bits. These components are called octets. Such disaggregation had the pleasant effect of reducing the human challenge of remembering a ten-digit number to merely remembering four numberseach of which is one octet in length. The valid numeric range for these octets is from 00000000 to 11111111. The decimal equivalents are 0 to 255. If you aren't sure why addresses were limited to this range, don't worry. This topic is covered in much more detail in the next section. A dot or period (.) was somewhat arbitrarily selected as the delimiter that would separate the fields. Thus, the convention was set: IP addresses would take this format:
This is the native form of IP addresses. Yet such a form might be confusing in that IP addresses are most commonly encountered in their decimal form. That is, they use Base10 numbers, which are separated by the dot or period. The term used to describe that form of an IP address is dotted-decimal notation. Here is an example of an IP address expressed in dotted-decimal notation:
All IPv4 addresses adhere to this format. Given the dotted-decimal format, two reasonable questions to ask are "Why bother saying that an IP address is a 32-bit number? Why not simply say that an IP address is four decimal numbers separated by dots?" The answer is that numbers are infinite, but the IP address space is not. It has a hard upper limit established by the 32 bits. It is necessary to explore binary mathematics to understand this statement. Binary MathematicsUnderstanding the IP address space absolutely requires comprehending the binary mathematics on which it is founded. Although this might sound somewhat daunting, it really is quite simple. As with anything, the more you use it, the easier it becomes. As mentioned earlier in this chapter, the address space is inherently binary; it uses the Base2 number system. Much like the Base10 number system, a digit's significance depends on its location. For example, the value of digits in the Base10 number system changes by a factor of 10 as you change columns. Thus, in the number 111, the numeral 1 has three different values: one group of 1s in the rightmost column, one group of 10 in the middle column, and one group of 100 in the leftmost column. Adding them results in the value 111. In the Base2 number system, the digits' significance also depends on their location. However, their value changes by a factor of 2 (not 10). The number 111, in binary, translates into one group of 1s, one group of 2s, and one group of 4s, for a total of 7 in Base10. Table 2-1 demonstrates how the binary number 10000000 translates into the Base10 number 128.
The eight binary digits and their decimal equivalents shown in Table 2-1 let you count from 0 to 255 in Base10 numbers. The building blocks of this capability are shown in Table 2-2. If the Base10 equivalent does not appear intuitive, refer to Table 2-1 to determine the decimal value of the Base2 columns.
The entries in Table 2-2 demonstrate the foundation on which the IP address space is built. Each of the four parts of an address contains just 8 bits with which to encode a value. However, only 1 of those 8 bits is actually set to a value other than 0. Notice how the decimal equivalent value doubles as the 1 moves left through the eight possible columns of the binary string of numbers. This demonstrates just the basic decimal values of the binary positions. However, the binary string can be used to encode decimal values that range from 0 to 255. Such values are calculated by adding the decimal values of each column populated with a 1. Counting in Base2 is fairly simple, because you have only two digits to work with! You increment from 0 to 1. Incrementing above that requires carrying values over into higher columns. This is the same logic that applies to Base10 and every other number system. For example, everyone knows that 9 + 1 = 10, but we seldom think about this equation in terms of columns and their respective values. What we are really saying is that 9 + 1 = one group of 10. The key difference between the Base2 and Base10 number systems is that the amount by which each column's value varies. In Base10, each column (progressing from right to left) is 10 times the value of the preceding column. In other words, the progression is ones, tens, hundreds, thousands. In Base2, the progression is a doubling of the value of the preceding column: 1, 2, 4, 8, 16, 32, 64, 128, and so on. Those values are represented in the Base2 number system by placing a 1 in their respective columns. This is illustrated in Table 2-2. The next logical step in mastering binary mathematics is learning how to count numbers that aren't factors of 2. See Table 2-3.
Without subjecting you to the tedium of counting all the way up to 255 in Base2, Table 2-3 attempts to demonstrate how to count in that number system. At first, the progression of the pattern of 1s and 0s might seem counterintuitive, but it follows the same logic as any other number system. There are only two symbols with which to encode values, so the highest "number" you can place in any column is a 1. To illustrate this point, suppose that the binary number is 00000001. Incrementing it by one unit requires resetting the rightmost column to 0 and carrying a 1 over into the column to its left. This yields 00000010. This is the same logic that is applied in decimal numbers when we increment 9 by 1 to get 10. In that equation, a group of nine 1s is increased by 1 to yield one group of 10 with no 1s. The difference lies in the number of valid numbers and the value of the columns. Quite literally, our binary number translates into decimal as follows: no groups of 128, no groups of 64, no groups of 32, no groups of 16, no groups of 8, no groups of 4, one group of 2, and no units. Summing up the groups yields a decimal value of 2. Another, slightly more complex example is the binary number 10101010. This binary number translates into decimal as follows: one group of 128, no groups of 64, one group of 32, no groups of 16, one group of 8, no groups of 4, one group of 2, and no units. Summing up the groups yields a decimal value of 170 (128 + 32 + 8 + 2). Therefore, to convert binary to decimal, you must sum up the decimal equivalents of all columns in the binary string that have a 1 instead of a zero. This summation must be done separately for each octet in the IP address.
|
EAN: 2147483647
Pages: 118