Cisco CCENT ICND1 100-101 Exam Cram: Concepts in IP Addressing

Date: Feb 10, 2014

Return to the article

The exam requires a perfect fluency in subnetting. Success requires speed and accuracy in answering the many questions you will see on this topic. The key to this level of fluency is practice—you must work at your skills until they become second nature.

The following sections discuss binary and hexadecimal numbering systems as compared with the more familiar decimal system. An understanding of binary, in particular, is crucial to success on the test as it is fundamental to computer systems in general, and to topics such as subnetting, access lists, routing, and route summarization. This chapter also looks at the relationship between the IP address and subnet mask in more detail, as well as how it can be manipulated for more efficient network functionality using route summarization. Finally, IP Version 6 is introduced and some of its features are explained.

Binary

Binary is the language of digital electronic communication. Binary is another name for Base 2 numbering. Our usual numbering system is Base 10, in which a single character or column can represent one of 10 values: 0, 1, 2, 3, 4, 5, 6, 7, 8, or 9. The first column indicates how many ones there are in a given value. To represent a value greater than 9, we need another column, which represents how many “tens” there are; if the value we want to represent is greater than 99, we use another column for the “hundreds,” and so on. You might notice that each additional column is ten times greater than the preceding one: ones, tens, hundreds, thousands, and so forth—all “powers of 10”: 100, 101, 102, 103, and so on. Base 10 is easy because most of us have 10 fingers and have known how to count from an early age.

In binary, or Base 2, a single character or column can represent one of only two values: 0 or 1. The next column represents how many “twos” there are; the next column how many “fours,” and so on. You’ll notice here that the value of each additional column is two times greater than the previous—all “powers of 2”: 20, 21, 22, 23, and so on. This is not a coincidence.

Given that a Base 2 or binary column can have only two possible values (0 or 1), this makes it easy to represent a binary value as an electrical value: either off (0) or on (1). Computers use binary because it is easily represented as electrical signals in memory or digital values on storage media. The whole system works because computers are quick at computing arithmetic, and as you’ll learn, pretty much all computer operations are really just fast binary math.

Let’s take a look at some Base 10 (or decimal) to binary conversions. Take the decimal number 176. Those three digits tell us that we have one 100, plus seven 10s, plus six 1s. Table 3.1 illustrates how decimal numbers represent this distribution of values.

TABLE 3.1 Decimal Values

100,000s	10,000s	1000s	100s	10s	1s
0	0	0	1	7	6

Notice that we have some 0s in the high-value columns; we can drop those from the beginning if we want to. You will not have to analyze decimal numbers in this way on the exam; we are simply demonstrating how Base 10 works so it can be compared to Base 2 and Base 16 in the same way.

In binary, the columns have different values—the powers of 2. Table 3.2 lists the values of the lowest 8 bits in binary.

TABLE 3.2 Binary Values

128

64

32

16

8

4

2

1

To represent the decimal number 176 in binary, we need to figure out which columns (or bit positions) are “on” and which are “off.” Now, because this is arithmetic, there are a few different ways to do this.

Start with the decimal number you want to convert:

176

Next, look at the values of each binary bit position and decide if you can subtract the highest column value and end up with a value of 0 or more. Ask yourself: “Can I subtract 128 from 176?” In this case, 176 – 128 = 48.

Yes, you can subtract 128 from 176 and get a positive value, 48. Because we “used” the 128 column, we put a 1 in that column, as shown in Table 3.3.

TABLE 3.3 Building a Binary String, Part 1

128	64	32	16	8	4	2	1
1

Now, we try to subtract the next highest column value from the remainder. We get 176 – 128 = 48. We take the 48 and subtract 64 from it.

Notice that you can’t do this without getting a negative number; this is not allowed, so we can’t use the 64 column. Therefore, we put a 0 in that column, as shown in Table 3.4.

TABLE 3.4 Building a Binary String, Part 2

128	64	32	16	8	4	2	1
1	0

Move along and do the math for the rest of the columns: 48 – 32 = 16. We then subtract 16 from 16 and get 0.

Note that when you get to 0, you are finished—you need to only fill the remaining bit positions with 0s to complete the 8-bit string. So, we used only the 128 column, the 32 column, and the 16 column. Table 3.5 is what we end up with.

TABLE 3.5 Completed Binary Conversion

128	64	32	16	8	4	2	1
1	0	1	1	0	0	0	0

176 decimal = 10110000 binary.

If you add up 128 + 32 + 16, you get 176. That is how you convert from binary to decimal: Simply add up the column values where there is a 1.

Hexadecimal

The CCENT exam will ask you a few questions on the conversion of binary to hexadecimal and back, so you need to understand how it works. An understanding of hex is also a useful skill for other areas of networking and computer science.

Binary is Base 2; decimal is Base 10; hexadecimal is Base 16. Each column in hex can represent 16 possible values, from 0 through 15. To represent a value of 10 through 15 with a single character, hex uses the letters A through F. It is important to understand that the values of 0 through 15 are the possible values of a 4-bit binary number, as shown in Table 3.6.

TABLE 3.6 Decimal, Binary, and Hex Values Compared

Decimal	Binary	Hex
0	0000	0
1	0001	1
2	0010	2
3	0011	3
4	0100	4
5	0101	5
6	0110	6
7	0111	7
8	1000	8
9	1001	9
10	1010	A
11	1011	B
12	1100	C
13	1101	D
14	1110	E
15	1111	F

Conversion Between Binary, Hex, and Decimal

The following sections provide an introduction to converting between binary, hex, and decimal. Again, there is more than one mathematical approach to finding the correct answer, but the method shown is simple and reliable.

Decimal to Hexadecimal Conversions

The easiest way to get from decimal to hexadecimal and back is to go through binary. Take the example we used earlier in which we converted 176 decimal to binary:

176 = 10110000

Given that a single hex character represents four binary bits, all we need to do is to break the 8-bit string 10110000 into two 4-bit strings like this:

1011 0000

Now, simply match the 4-bit strings to their hex equivalent:

1011 = B

0000 = 0

The answer is simply 10110000 = 0xB0.

The 0x in front of the answer is an expression that means “the following is in hex.” This is needed because if the hex value was 27, we could not distinguish it from 27 decimal.

Hexadecimal to Decimal Conversions

The reverse of the procedure is easier than it seems, too. Given a hex value of 0xC4, all we need to do is to first convert to binary, and then to decimal.

To convert to binary, take the two hex characters and find their binary value:

C = 1100

0100 = 4

Now, make the two 4-bit strings into one 8-bit string:

11000100

Finally, add the bit values of the columns where you have a 1:

128 + 64 + 4 = 196

IP Address Components

CCNA candidates need to be fluent in their understanding of IP addressing concepts. The following sections detail how IP addresses are organized and analyzed, with a view to answering subnetting questions.

Address Class

Early in the development of IP, RFC 791 designated five classes of IP address: A, B, C, D, and E. These classes were identified based on the pattern of high-order bits (the high-value bits at the beginning of the first octet). The result is that certain ranges of networks are grouped into classes in a pattern based on the binary values of those high-order bits, as detailed in Table 3.7.

TABLE 3.7 Address Class and Range

Class	High-Order Bits	1st Octet Range
A	0	1–127
B	10	128–191
C	110	192–223
D	1110	224–239
E	11110	240–255

You might notice that 127 is missing. This is because at some point the address 127.0.0.1 was reserved for the loopback (sometimes called localhost) IP—this is the IP of the TCP/IP protocol itself on every host machine.

Public and Private IP Addresses

As the popularity of TCP/IP increased, many organizations wanted to use it in their own networks, without paying to be connected to the Internet. The IETF published a Recommended Best Practice (RFC 1918) that defined several “private” IP networks that could be used by individuals, corporations, or other organizations without needing to pay to lease them from an Internet service provider (ISP). The tradeoff was that these networks were not routable on the Internet because these addresses were filtered from the route tables on Internet routers and so were unreachable from the Internet. They work exactly the same as any other IP address in every other respect; in fact, if they weren’t filtered they would work on the Internet too.

These address ranges will probably be familiar to you already, because every LAN you have ever joined likely used one of them. To access the Internet from a LAN using one of these private, non-routable networks, we have to go through a Network Address Translation (NAT) router. NAT is explained in Chapter 10, “IP Services.” Table 3.8 lists the private IP Address ranges. You should commit these to memory and be able to recognize them at a glance.

TABLE 3.8 Private IP Address Ranges

Class	Range
A	10.0.0.0 to 10.255.255.255
B	172.16.0.0 to 172.31.255.255
C	192.168.0.0 to 192.168.255.255

Default Subnet Mask

Each class of address is associated with a default subnet mask, as shown in Table 3.9. An address using its default mask defines a single IP broadcast domain—all the hosts using that same network number and mask can receive each other’s broadcasts and communicate via IP.

TABLE 3.9 Address Class and Default Masks

Class	Default Mask
A	255.0.0.0
B	255.255.0.0
C	255.255.255.0

One of the rules that Cisco devices follow is that a subnet mask must be a contiguous string of 1s followed by a contiguous string of 0s. There are no exceptions to this rule: A valid mask is always a string of 1s, followed by 0s to fill up the rest of the 32 bits. (There is no such rule in the real world, but we will stick to the Cisco rules here; it’s a Cisco exam, after all.)

Therefore, the only possible valid values in any given octet of a subnet mask are 0, 128, 192, 224, 240, 248, 252, 254, and 255. Any other value is invalid.

The Network Field

Every IP address is composed of a network component and a host component. The subnet mask has a single purpose: to identify which part of an IP address is the network component and which part is the host component. Look at a 32-bit IP address expressed in binary, with the subnet mask written right below it. Figure 3.1 shows an example.

Anywhere you see a binary 1 in the subnet mask, it means “the matching bit in the IP address is part of the network component.” In this example, the network part of the address is 192.168.0.X, and the last octet (X) will be the host component.

Because there are 24 bits in a row in the mask, we can also use a shortcut for the mask notation of /24. These examples show how a dotted-decimal mask can be expressed in slash notation:

192.168.1.66 255.255.255.0 = 192.168.1.66 /24

172.16.0.12 255.255.0.0 = 172.16.0.12 /16

10.1.1.1 255.0.0.0 = 10.1.1.1 /8

This slash notation is sometimes called CIDR (classless interdomain routing) notation. For some reason, it’s a concept that confuses students, but honestly it’s the easiest concept of all: The slash notation is simply the number of 1s in a row in the subnet mask. The real reason to use CIDR notation is simply that it is easier to say and especially to type—and it appears interchangeably with dotted-decimal throughout the exam. CIDR notation also appears in the output of various IOS commands.

Every IP address has a host component and a network component, and the 1s in the mask tell us which bits in the address identify the network component.

The Host Field

If the 1s in the mask identify the network component of an address, the 0s at the end of the mask identify the host component. In the preceding example, the entire last octet is available for the host IP number.

The number of 0s at the end of the mask mathematically define how many hosts can be on any given network or subnet. The 1s in the mask always identify the network component, and the 0s at the end of the mask always identify the host component of any IP address.

Nondefault Masks

At this point, you should be able to recognize what class an address belongs to, and what its default mask is supposed to be. Here’s the big secret: If a mask is longer than it is supposed to be, that network has been subnetted. So, it is clearly another critical skill that you be able to spot those nondefault masks.

The Subnet Field

Because we have extended the subnet mask past the default boundary into the bits that were previously host bits, we identify the bits we “stole” from the host part as the subnet field. The subnet field is relevant because those bits mathematically define how many subnets we create. Figure 3.2 uses the same IP address from our previous example, but now we have applied a mask that is longer than the default. Note that this creates the subnet field.

Figure 3.2 identifies the two extra bits past the default boundary as the subnet field—they used to be in the host field, but we subnetted and stole them to become the subnet field.

Subnetting

Subnetting is not as difficult as it initially seems. Because we are dealing with arithmetic, there is definitely more than one way to do this, but the method shown here has worked well. The following sections work through the process of subnetting. Then, we work on some shortcuts to show how you can subnet quickly because CCNA exam candidates often find that they are pressed for time on the exam.

Address Class and Default Mask

Subnetting happens when we extend the subnet mask past the default boundary for the address we are working with. So it’s obvious that we first need to be sure of what the default mask is supposed to be for any given address. Previously, we looked at the RFC791 designations for IP address classes and the number ranges in the first octet that identify those classes. If you didn’t pick up on this before, you should memorize those immediately.

When faced with a subnetting question, the first thing to do is decide what class the address belongs to. Here are some examples:

192.168.1.66

The first octet is between 192 and 223: Class C

Default mask for Class C: 255.255.255.0

188.21.21.3

The first octet is between 128 and 191: Class B

Default mask for Class B: 255.255.0.0

24.64.208.5

The first octet is between 1 and 126: Class A

Default mask for Class A: 255.0.0.0

It’s important to grasp that if an address uses the correct default mask for its class, it is not subnetted. This means that regardless of how many hosts the 0s at the end of the mask create, all those hosts are on the same network, all in the same broadcast domain. This has some implications for classful networks (ones that use the default mask for the address). Take a Class A for example: A Class A network can have 16,777,214 hosts on it. Almost 17 million PCs on one network would never work—there would be so much traffic from broadcasts alone, never mind regular data traffic, that nothing could get through and the network would collapse under its own size. Even a Class B network has 65,534 possible host IPs. This is still too many. So, either we waste a lot of addresses by not using the whole classful A or B network, or we subnet to make the networks smaller.

This is actually one of the most common reasons we subnet: The default or classful networks are too big, causing issues such as excessive broadcast traffic and wasted IP address space. Subnetting creates multiple smaller subnetworks out of one larger classful network, which allows us to make IP networks the “right” size—big or small—for any given situation.

The Increment

By definition, the process of subnetting creates several smaller classless subnets out of one larger classful one. The size of these subnets, or how many IP addresses they contain, is called the increment. Because we are working with binary numbers, a pattern emerges in which the increment is always one of those powers of 2 again—another good reason to memorize those numbers.

The increment is really easy to figure out. It is simply the value of the last 1 in the subnet mask. Let’s look at some examples. Figure 3.3 shows an IP address and subnet mask in binary.

Note that this is a Class C address, and it uses the correct default mask—so it is not subnetted. This means that there is only one network, so there isn’t really an increment to worry about here. It’s sufficient at this point to recognize that an address that uses its default mask creates one network (no subnets), so there is no subnetted increment to consider.

Let’s take the same address and subnet it by extending the mask past the default boundary, as shown in Figure 3.4.

The very last 1 in the subnet mask in the figure is in the bit position worth 64—so the increment in this case is 64, which means that the subnets we made are evenly spaced at 64 IP addresses apart.

Think about this for a second. We are doing the subnetting in the fourth octet—that is where the mask changes from 1s to 0s. (The octet where this happens is sometimes referred to as the interesting octet.) The lowest possible value in that fourth octet is 0. If the subnets are 64 IP addresses apart, this means that the first subnet starts at 0, the next one starts at 64, the third at 128, and the fourth at 192—all multiples of the increment. Note that if we add another 64 to that last 192, we get 256—and that is larger than 255, the largest value that is possible in one octet. So this means we only have room for four subnets. Figure 3.5 illustrates this pattern more clearly.

The multiples of the increment—0, 64, 128, and 192—are the starting addresses of the subnets we created. The subnets are all 64 addresses long, so we have room to make four subnets before we run out of addresses in the fourth octet.

Figure 3.6 shows our IP and subnet mask—note that the value of the last “1” in the mask is 16—and the subnets created with that increment of 16.

First of all, you should notice that we are subnetting again—the mask extends past the default boundary. The last 1 in the mask is in the bit position worth 16, so our increment is 16. The multiples of 16 are 0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, and 240. Again, we can’t make another subnet because 240 + 16 = 256. Be careful not to start doubling as we did with the binary values; here we are just adding the increment value each time. It’s easy to get confused!

The increment is really the key to subnetting; if you can determine the increment, you can see how big your subnets are and how many you have created. Remember, the easy way to find the increment is to just determine the bit value of the last 1 in the mask.

Number of Hosts

The number of 0s at the end of the mask always defines the number of hosts on any network or subnet. There is a simple mathematical formula that defines how many IP addresses are available to be assigned to hosts.

Now, no one expects you to be a big fan of algebra, but you need to see and understand the formula.

The number of binary bits you have to use determines the maximum number of different values you can express using those bits. If you have 3 bits, you can make eight different values—0 through 7, or 000 through 111 in binary; 3 bits, and 2³ = 8—this is not a coincidence. The binary values you learned earlier—1, 2, 4, 8, 16, 32, 64, and 128—are all powers of 2 and define the maximum number of different values you can create if the mask ends in that bit position. So it should come as no surprise that the formula for the number of hosts on any network or subnet is 2^H – 2, where H is the number of 0s at the end of the mask.

But why do we subtract 2 in the formula? It’s pretty straightforward: Every network or subnet has two reserved addresses that cannot be assigned to a host. The rule is that no host can have the IP address in which all the host bits are set to 0, and no host can have the IP address in which all the host bits are set to 1. These addresses are called the network ID and the broadcast ID, respectively. They are the first and last IP addresses in any network or subnet. We lose those two IP addresses from the group of values that could be assigned to hosts.

Think of a network or subnet as a street with houses on it. Each house has a unique address, and the street has a name. The network ID is like the street name, and all the houses are hosts on a subnet that is known by its network ID street name. If two hosts have identical network and subnet fields in their addresses, they are on the same network, and can ping each other and exchange data and all that good stuff. If the network and subnet fields are different, even by 1 bit, they are on different networks and can’t communicate until we put a router between them. The routers act like street intersections; you must get to the right intersection (router) before you can get on to the street you want (but we’ll save that for later).

In a network where there are no routers, devices running TCP/IP make a decision about whether a particular IP address is on the network by performing a logical AND operation. The AND is a Boolean function that works like this:

1 AND 1 = 1

0 AND 1 = 0

1 AND 0 = 0

0 AND 0 = 0

This operation applies to IP networking like this: A host does a logical AND between its own IP and its mask. This determines its network ID. The host can then do an AND between another IP address and its own mask to determine if that second address is on the same network or some other one.

Let’s take the IP address and mask of an imaginary host and display them in binary, as shown in Figure 3.7. The AND operation takes each bit in the address and ANDs it with the corresponding bit in the mask below it; the result is the network ID of the host.

Now the host knows its own network ID and can compare any other host’s address to that to see if the other host has the same network ID. If the two network IDs are different, traffic has to be sent through a router to get to the other network—and if there is no router, the two hosts can’t communicate.

The Broadcast ID

The broadcast ID is the address that represents every host on that network or subnet. Sometimes called a directed broadcast, it is the common address of all hosts on that network ID. This should not be confused with a full IP broadcast to the address of 255.255.255.255, which hits every IP host that can hear it; the broadcast ID hits only hosts on a common subnet.

Let’s take the previous example of an increment of 64 and expand on the detail, as shown in Figure 3.8.

Note that all the multiples of the increment—the numbers that mark the start of each subnet—have been identified by an N for network ID, and the last IP in every subnet is marked with a B for broadcast ID. This leaves us with 62 IPs left over in each subnet, and any of these (but only these) can be assigned to a host.

This leaves us with a range of IP addresses within every network or subnet that can be assigned to hosts. There is an unofficial convention that the gateway or router for a subnet is assigned the first or the last IP address available, but that is entirely arbitrary.

The first valid IP address is defined as

Network ID + 1

In Figure 3.8, the first valid host IPs in each subnet are .1, .65, .129, and .193.

The last valid host is defined as

Broadcast ID – 1

In Figure 3.8, the last valid host IPs in each subnet are .62, .126, .190, and .254.

See how the subnetted mask in the previous example has shortened the number of 0s at the end of the mask as compared to the default of 8? We now have only six 0s in the host part, so our formula would be

2⁶ – 2 = 62

Here’s something interesting: It doesn’t matter what IP address you use with this mask; that mask will always give you 62 hosts on each subnet. You can pick a Class A address, say 22.1.1.0, and that mask would still make 62 hosts per subnet. The number of 0s at the end of the mask always drives how many hosts are on each subnet, regardless of the address.

So, what happened to all the other host IPs we started with? Remember that subnetting takes a classful A, B, or C network and splits it into several equalsized pieces. It’s just like cutting a pie into pieces; the original amount of pie is still there, but each piece is now separate and smaller.

Remember that the number of 0s at the end at the mask always defines how many hosts are on each subnet, regardless of the address in use.

Number of Subnets

Following on with the pie analogy, we know that we slice a classful network into pieces—but how many pieces? There is a simple mathematical relationship to this as well, but it is slightly more complex because of an old rule that we sometimes have to deal with.

The basic formula for the number of subnets is similar to the hosts formula. It is simply 2^S, where S is the number of bits in the subnet field—that means the number of 1s in the mask past the default boundary for that address. If you look at Figure 3.9, you can see how this works.

The default boundary for that Class C address should be at the 24th bit, where the third octet ends and the fourth begins. The subnetted mask extends that by 2 bits into the fourth octet. So, we have stolen 2 bits, and our formula would look like this:

# of subnets = 2^S

S = 2

2² = 4

We made four subnets, as you saw earlier. To figure out how many bits we stole, we first must know where the default boundary is so that we know where to start counting. This is where knowing the address classes and the correct default masks is critical; if you can’t figure this out, you will not be able to answer most subnetting questions correctly, and that would be bad.

Now here’s where things get tricky. A rule that some older systems use says that the first and last subnets created are invalid and unusable. The rule is known as the Subnet Zero Rule, and obviously if it is in effect, we lose two subnets from the total we create. These two subnets will be referred to from now on as the zero subnets. Newer systems do not use the Zero Subnets Rule, including newer Cisco devices. This is confusing and makes things more difficult—but difficult is not something Cisco shies away from on its certification exams. So if you want your CCNA, pay attention to the question and don’t complain about how hard it is.

The Cisco IOS supports the use of the zero subnets. The command ip subnet zero turns on the ability to use them, so that might be how the question is telling you whether they are in effect. Once you pass your CCNA, you will not likely have to worry about the Zero Subnets Rule again, unless you lose your mind and decide to become a Cisco trainer.

Working with Subnetting Questions

Determining Host Requirements

There are only two scenarios when determining the host requirements: Either you are given a mask and asked how many hosts per subnet this creates or you are given a requirement for a certain number of hosts and asked to provide the appropriate mask. Either way, the number of 0s at the end of the mask drives how many hosts per subnet there will be; the address to which that mask is applied is irrelevant. Your task is to put the correct number of 0s at the end of the mask such that 2^H – 2 is greater than or equal to the desired number of hosts, or to determine what the value of 2^H– 2 actually is. From there, you must choose the correct expression of the mask, either in dotted-decimal or CIDR notation.

Determining Subnet Requirements

The scenarios for determining subnet requirements are quite similar to the host questions. Either you are told how many subnets you need and asked to provide the appropriate mask or you are given a mask and asked how many subnets it creates. Note that in both cases (unlike hosts questions), you must know the IP address or at least the class of address you are working with. Creating subnets happens by extending the default mask, so you must know where the mask should end by default—and for that you need to know the class of address. Once you know where to start, simply extend the mask by the correct number of subnet bits such that 2^S – 2 (or possibly just 2^S) gives you the correct number of subnets.

Determining Increment-Based Requirements

Increment questions are the most challenging and complex subnetting questions, often requiring you to do a lot of legwork before you can get to the answer.

Increment questions often give you two or more IP addresses and masks, and ask you things such as, “Why can’t Host A ping Host B?” The answer could be that A and B are on different subnets. To determine this, you need to understand where those subnets begin and end, and that depends on the increment. Another popular question gives you several IP addresses and masks that are applied to PCs, servers, and routers. The system, as it is described, is not working, and you need to determine what device has been incorrectly configured—perhaps two IPs in different subnets, perhaps a host that is using a network ID or broadcast ID as its address.

The key is to first determine what the increment is or should be; then, carefully plot out the multiples of the increment—the network IDs of all the subnets. Then you can add the broadcast IDs, which are all one less than the next network ID. Now you have a framework into which you can literally draw the host IP ranges, without risk of “losing the picture” if you do this all in your head.

All of these skills take practice. Everyone goes through the same process in learning subnetting: For quite a while, you will have no idea what is going on—then suddenly, the light goes on and you “get it.” Rest assured that you will get it. It takes longer for some than others, and you do need practice or you will lose the skill.

The Subnetting Chart

You should now understand concepts and mechanics of subnetting. You can do it and get the right answer almost all of the time, but it takes you a while. This is good—congratulations! If you are not at that point yet, you should practice more before you look at this next section.

What follows is one of many variations of a subnetting chart. This is a good one because it is easy to use under pressure when your brain will behave unpredictably.

The chart represents the last two octets of a subnet mask, and what effect a 1 or a 0 in the different bit positions will have. It lists the increment, CIDR notation, the mask in decimal, the number of hosts created, and the number of subnets formed from a Class B and C address. Use an acronym to help get the rows correct: “Internet Class May Have Been Canceled.” (I = increment, C = CIDR, M = mask, H = host, B = B hosts, C = C hosts). Figure 3.10 shows a completed version.

The following are steps to re-create the chart:

1. The first row is simply the binary bit position values—the powers of 2. Start at the right with 1 and keep doubling the value as you go left: 1, 2, 4, 8, 16, 32, 64, 128. Repeat for the third octet.
2. The second row is the CIDR notation—the number of 1s in a row in the mask. Our chart starts at the 17th bit, so number the second row starting at 17, through 32.
3. The third row is the mask in binary. Add consecutive bit values together from left to right to get the valid mask values of 128, 192, 224, 240, 248, 252, 254, and 255. Or you can just memorize them.
4. The fourth row is the number of hosts created. Starting at the right side of the fourth octet, subtract 2 from the increment line (the first line) and enter that value. Do this for the whole fourth octet. When you get to the third octet (the left half of the chart), you will have to change your approach: The value will keep increasing in the same pattern, but subtracting 2 from the top row won’t work anymore because the top row resets for the third octet. The simplest approach is to double the last value and add 2. For example, (126 × 2) + 2 = 254, (254 × 2)+2 = 510, and so on.

5. The fifth row is the number of subnets created from a Class B address. Starting at the left side of the chart (the third octet), repeat the values from the first line, but in reverse order. Remember to start at 2!.

   Caution

   Remember that the Zero Subnets Rule will change your answers and how you use your chart. If the zero subnets are not allowed, simply deduct 2 from the values in lines 5 and 6 of your chart in the appropriate octet.

6. The sixth row of the chart is the number of subnets created from a Class C address. Remember, with a Class C, we do not make any subnets (that is, we have only one network) in the third octet, so we have all 1s there. For the fourth octet, the numbers are the same as in row 5; just start them in the fourth octet instead. The same caution and tactic about the zero subnets applies.

Provided you have built it correctly, your chart is a huge help in answering subnetting questions quickly and accurately. All you need to do is determine what the question is asking for, and then look up that value on your chart. All of the answers you need will be in the same column. Practice building and using the chart until it becomes something you can do without thinking. You will need your brain for other more complicated problems.

VLSM

Variable-length subnet masking or VLSM can be defined as the capability to apply more than one subnet mask to a given class of addresses throughout a routed system. Although this is common practice in modern networks, there was a time when this was impossible because the routing protocols in use could not support it. Classful protocols such as RIPv1 do not include the subnet mask of advertised networks in their routing updates; therefore, they cannot possibly learn the existence of more than one mask length. Only classless routing protocols—EIGRP, OSPF, RIPv2, IS-IS, and BGP—include the subnet mask for the networks they advertise in their routing updates and thus publish a level of detail that makes VLSM possible.

The main push for VLSM came from the need to make networks the right size.

Subnetting logically creates the appropriately sized networks, but without the capability for routing protocols to advertise the existence (for example) of both a /26 and a /30 network within the same system. Prior to VLSM-capable routing protocols, the network in our example would have been confined to using only /26 masks throughout the system. The use of VLSM has two main advantages that are closely linked:

• It makes network addressing more efficient.
• It provides the capability to perform route summarization (discussed in the next section).

An illustration of the need for VLSM is shown in Figure 3.11.

The diagram shows several branch offices using subnetted Class C (/26) addresses that provide each branch with 62 possible host IPs. The branches are connected to the central office via point-to-point WAN links. The ideal mask to use for such a link is /30 because it provides only two hosts, one for each end of the link. The problem arises when the routing protocols are configured: Prior to VLSM, the /30 networks could not be used because the /26 networks existed in the same system and the classful routing protocols could only advertise one mask per class of address. All networks, including the little /30 links, had to use the same mask of /26. This wastes 60 IP addresses on each WAN link.

With the implementation of VLSM-capable routing protocols, we can deploy a /30 mask on the point-to-point links, and the routing protocols can advertise them as /30s along with the /26s in the branches because the subnet mask for each network is included in the routing updates. Figure 3.12 illustrates the preferred, optimized addressing scheme that takes advantage of VLSM.

Note that using VLSM has allowed us to make the point-to-point link networks the ideal size (two hosts on each) using /30 masks. This has allowed us to use a single subnetted Class C network for all the addressing requirements in this scenario—and as you’ll see, it makes a perfect opportunity to summarize these routes. This is what is meant by “more efficient addressing”—in other words, making networks the right size without depleting the limited address space or limiting future growth.

Route Summarization

If subnetting is the process of lengthening the mask to create multiple smaller subnets from a single larger network, route summarization can be described as shortening the mask to include several smaller networks into one larger network address. As the network grows large, the number of individual networks listed in the IP route table becomes too big for routers to handle effectively. They get slower, drop packets, and even crash. This, of course, is an undesirable state of affairs. With more than 450,000 routes (at the time of this writing, anyway) known to major Internet routers, some way to reduce the number of entries is not only desirable, but also critical.

In the previous VLSM example, all the subnets for the branches and the WAN links were created from the 192.168.0.0 /24 Class C network. If we take that diagram and put it into context, we can see how route summarization can reduce the number of entries in the route table, as shown in Figure 3.13.

The Central Office router can either send a routing update with all the subnets it knows about listed individually, or it can send a single line in the update that essentially says, “Send anything that starts with 192.168.0 to me.” Both methods work; the issue is one of scalability. No router will ever collapse under the load of advertising six subnets, but make it 6,000 subnets and it makes a huge difference in performance if you summarize as much as possible.

Route summarization takes a set of contiguous networks or subnets and groups them together using a shorter subnet mask. The advantages of summarization are that it reduces the number of entries in the route table, which reduces load on the router and network overhead, and hides instability in the system behind the summary, which remains valid even if summarized networks are unavailable.

Summarization Guidelines

It is important to follow a few rules and guidelines when summarizing. Serious routing problems will happen otherwise—such as routers advertising networks inaccurately and possibly duplicating other routers’ advertisements, suboptimal or even totally incorrect routing, and severe data loss.

The first rule is to design your networks with summarization in mind, even if you don’t need it yet. This means that you will group contiguous subnets together behind the router that will summarize them—you do not want to have some subnets from a summarized group behind some other router. The summary is essentially saying, “I can reach the networks represented by this summary; send any traffic for them through me.” If one (or more) of the networks behind the summarizing router is unavailable, traffic will be dropped—but not by the summarizing router, because the individual routes to the networks that were summarized are still valid, and have a longer match entry than the summary. The packet will get routed to the router that connects to the dead network, and dropped there. Advance planning, including making plenty of room for future growth, will give you a solid, scalable network design that readily lends itself to summarizing. Figure 3.14 shows a badly designed network that will be almost impossible to summarize because the subnets are discontiguous, with individual subnets scattered all over the system.

The second rule is to summarize into the core of your network. The core is where the bigger, faster, busier routers are—like the Central Office router in the previous example. These routers have the job of dealing with high volumes of traffic headed for all different areas of the network, so we do not want to burden them with big, highly detailed route tables. The further you get from the core, the more detail the routers need to get traffic to the correct destination network. It’s much like using a map to drive to a friend’s house; you don’t need a great deal of detail when you are on the highway, but when you get into the residential areas, you need to know very precise information if you have a hope of finding the place.

Figure 3.15 illustrates the same network after your friendly neighborhood Cisco Certified Internetwork Expert has spent the afternoon re-addressing the network and configuring summarization. This network will scale beautifully and have minimal performance issues (at least because of route table and routing update overhead).

Following these rules will give you one of the additional benefits of summarization as well: hiding instability in the summarized networks. Let’s say that one of the branches is having serious spanning-tree problems because Sparky the Junior Woodchuck was allowed to configure a Cisco switch. (This is actually a felony in some states.) That route could be “flapping”—up, down, up, down—as spanning-tree wreaks havoc with your network. The router will be doing its job, sending out updates every time the route flaps. If we were not summarizing, those flapping messages would propagate through the entire corporate system, putting a totally unnecessary and performance-robbing load on the routers. Once you summarize, the summary is stable: It can’t flap because it is not a real network. It’s just like a spokesperson at a press conference: “The rumors of a fire at the Springfield plant have had no impact on production whatsoever.” Meanwhile, the Springfield plant could be a charred hulk. The summary is still valid, and traffic will still be sent to the router connected to the flapping network. This keeps people from asking any more questions about the Springfield fire. However, if someone were to send a shipment to Springfield, it would be hastily redirected to another site (or dropped). All we have done is hide the problem from the rest of the world so that we don’t flood the Internet with rapid-fire routing updates.

Determining Summary Addresses

When using routing protocols in classless configurations, creating summary addresses is a totally manual process. Classful routing protocols perform automatic summarization, but that is not as fancy as it sounds. They simply treat any subnet as the classful address from which it was created, which works if your networks are built with this in mind; however, in reality that is too simplistic and real networks need more customized summarization. The upshot of all this is that you need to understand how to determine the summary address given a set of networks to be summarized, and you also need to be able to figure out if a particular network is included in a given summary.

Remember that summarization is exactly the opposite of subnetting; in fact, another term for summarization is supernetting. (You might also see it called aggregation.) When we subnet, we lengthen the mask, doubling the number of networks each time we add an extra bit to the mask. Supernetting does the opposite: For each bit we retract or shorten the mask, we combine networks into groups that follow the binary increment numbers.

To illustrate this, let’s look at the private Class B address space. These networks are listed as follows:

• 172.16.0.0 /16
• 172.17.0.0 /16
• 172.18.0.0 /16
• 172.19.0.0 /16
• 172.20.0.0 /16
• 172.21.0.0 /16
• 172.22.0.0 /16
• 172.23.0.0 /16
• 172.24.0.0 /16
• 172.25.0.0 /16
• 172.26.0.0 /16
• 172.27.0.0 /16
• 172.28.0.0 /16
• 172.29.0.0 /16
• 172.30.0.0 /16
• 172.31.0.0 /16

If you look carefully, you will notice that the range of networks is identified in the second octet. The octet where the range is happening is referred to as the interesting octet. This is your first clue where to begin your summarization.

The next step is to figure out what the binary values of the network’s range are. The binary values for the interesting octet are shown in Figure 3.16.

You should see a pattern in the binary values: The first 4 bits are all the same. The range is actually happening in the last 4 bits in the second octet; those 4 bits range from 0000 through 1111; the first 4 bits are common for all 16 networks in the range.

The next step is to identify those common bits. While you are learning how to do this, it’s a good idea to write out the binary for the range and draw a line that represents the boundary between the common bits and the variable bits in the range. Remember, be absolutely sure that your boundary line is in the right place: For all the networks in the range, everything to the left of the line must be identical, and everything to the right will be the ranging values.

The next step is easy. We are about to summarize: All we need to do is to build a subnet mask that puts a 1 under all of the common bits in the range, and a 0 under everything else—1s to the left of the boundary, and 0s to the right, as shown in Figure 3.17.

The last step is to actually create the summary statement. A summary is always an IP address plus a mask; the IP is usually a network ID, and it should be the first network in the range. In our example, the first network ID is 172.16.0.0 so that is the IP we will use. For the mask, the first octet is the same in the whole range, and we have figured out that the first four bits in the second octet are always the same. Remembering that a mask is always a string of 1s followed by a string of 0s, this means that we should mask all 8 bits in the first octet and the first 4 in the second octet, so our mask looks like this:

11111111.11110000.00000000.00000000

That can also be expressed as

255.240.0.0 or /12

So, our summary statement becomes

172.16.0.0 255.240.0.0

or

172.16.0.0 /12

Reverse engineering this is the same process. You are given a summary statement and asked what networks it includes. The octet in which the mask changes from 1s to 0s is the interesting one, where the range will be defined. Jot down the address and mask in that octet in binary and see what possible values are in the range. Then check the networks to see if those are in the range. Figure 3.18 gives an example.

IPv6

Up to this point, when we talked about IP or an IP address, we were referring to IP Version 4. IPv4 was created to build a Defense Department network in the early 1970s. At the time, no one foresaw that the Internet as we know it today was going to happen. The designers of the TCP/IP suite of protocols did not plan for their little project to balloon into the largest network in the world and revolutionize the commercial, cultural, and communications behavior of the whole planet.

But it did, and a couple problems came to light rather quickly when the Internet started to really catch on. One really tricky one was that the address “space” was originally handed out without quite enough thought and planning as to who got what size chunks, and what routers would be responsible for those chunks. At the time it didn’t matter; there were plenty of addresses to go around. But as the routers started to get really large route tables, with all these networks being added, they had trouble dealing with it. Routers at the time were relatively small and slow, and when the route tables became so large, they were overloaded, slow to do their jobs, and generally poor performers. Solutions were urgently needed because the Internet was growing very fast and the problem was only getting worse.

The solutions came in things like VLSM-capable protocols, route summarization, a reassignment and redistribution of addresses, and the NAT service. These solutions have allowed the IPv4 address space to continue to function and serve as the address system for the Internet, but the second problem is one we can’t get around: The mathematical reality is that there are not enough IP addresses available to meet the demand (especially in Europe and Asia). More people want Internet addresses than there are addresses to hand out.

This is where IPv6 comes in. Whereas an IPv4 address is a 32-bit string, theoretically providing more than 4 billion IP addresses (for the sake of clarity I’ll ignore the fact that a large number of theses addresses are not really usable). An IPv6 address is 128 bits long, providing about 3.4 × 10³⁸ possible addresses, or as the story goes, 500,000,000,000,000,000,000,000,000,000 addresses for each of the 6.5 billion people on the planet. Running out of IPv6 addresses is not expected to be a problem.

Along with the sheer number of addresses available, IPv6 also cleans up a few of the issues with IPv4, making the operation and management of large internetworks easier and more efficient, and adds some useful new functionality as well. So now we can easily envision a world where anything we want can have an Internet IP address (including silly things such as the fridge), where an Internet-enabled mobile phone can keep its IP address as it moves across the globe, and all the difficulty and headache caused by using VPNs through NAT disappears.

IPv6 Address Allocation

An organization called the Internet Corporation for Assigned Network Numbers (ICANN) has the overall responsibility for dividing up the IPv6 address space. They do so with the benefit of a better understanding of the global demand for Internet IP addresses and the luxury of a huge number of addresses to hand out.

The system works like this: First, remember that for the Internet to work well, we need to use route summarization so that the route tables don’t get huge and slow the routers down. Route summarization works best if every router is responsible only for its “branch of the tree,” with smaller branches feeding into larger and larger ones as we get closer to the core or trunk of the tree. This allows the possibility for a single router to advertise a summary that in effect says, “I can reach all North American routes.” That big router connects to other routers that summarize routes for four major Internet service providers (ISPs). Each ISP router connects to smaller ISPs or large enterprise customers, who advertise the summaries that represent the addresses assigned to them. Figure 3.19 gives some idea of how this system works.

The beauty of the system is that it is organized, planned, and executed in advance, with efficient routing in mind. The large number of addresses available also means that changes at or below the ISP level, for example, because of mergers or large customers changing Internet providers, do not affect the global routing information at the core.

IPv6 Address Notation

IPv6 addresses are different in appearance from IPv4. Of course, they are 128 bits long, so even in binary they would be four times longer than a 32-bit IPv4 address, but in notation that humans read and write the format is still different. Instead of using dotted-decimal in four octets, we use hexadecimal in eight sets of four characters separated by colons, like this:

2201:0FA0:080B:2112:0000:0000:0000:0001

The use of hex makes it a little easier to represent all those 128 bits in a shorter format because each character represents 4 bits. But it’s still a long thing to type out, and remember that network people are generally lazy—so we have a couple of truncation methods to make the long addresses even shorter. The first method is that we are allowed to drop leading 0s (0s that appear at the beginning of each set), like so:

2201:FA0:80B:2112:0:0:0:1

That makes for a little less typing and a little more clarity. Pay attention to the fact that dropping 0s at the end of each set is not allowed! Dropping leading 0s does not change the value of the set; dropping 0s at the end does (like removing a 0 from the end of your paycheck amount—not good!)

The second truncation method we can use is to condense contiguous groups of all-0 sets. In our example, there are three sets that are all 0s. We can represent these by a double colon, like this:

2201:FA0:80B:2112::1

This is as short as it gets. We are only allowed to do the double-colon trick once in any address, so if you see an address with two double-colons in it, it is not valid. Here’s an example:

2201::BCBF::1

One last piece of the addressing notation: the mask. We do not represent the mask as another set of hex characters. Instead, we identify the prefix length with slash notation. This is not as confusing at it seems: The slash notation simply identifies how many bits identify the network part, with the remainder being the host part.

For example, the North American registry ARIN (American Registry for Internet Numbers) was given the block of 2620:0000::/23 in September 2006. This indicates that the first 23 bits of 2620:0000:: identify the block of addresses that the North American routers will advertise to the rest of the world. From this point, ARIN will assign chunks of that space to the Big ISPs; Big ISP1 might get 2620:0100::/24, and Big ISP2 might get 2620:0200::/24. Those ISPs then hand out pieces of their chunk to smaller ISP or big customers, and the prefix length will get bigger as the chunks gets smaller—this should feel familiar because what we are doing here is subnetting. Don’t worry, you won’t be expected to subnet in IPv6. Not yet at least.

Types of IPv6 Addresses

An IPv6 address will be one of the following types. Some will be familiar, but there is one brand-new one, too.

• Unicast: An IPv6 unicast address is the same as an IPv4 unicast address; it is an IP that is assigned to an interface on a host. It can be the source of an IP packet or the destination for one. A packet sent to a unicast address goes to the one host with that address.
• Global unicast: A global unicast IPv6 address is the equivalent of a public, registered IP address. They are Internet routable, globally registered IPs that must be leased from an ISP.
• Unique local: Equivalent to a private IPv4 address; not registered with an ISP and not Internet routable.
• Link local: Every IPv6 interface gives itself a link-local address. The address range is FE80::/10, and usually combines this prefix with the last 64 bits in EUI-64 format. It is roughly equivalent to the Automatic Private IP Address (APIPA) address range of 169.254.0.0/16.
• Multicast: Just like in IPv4, a single IPv6 multicast address is assigned to multiple hosts so that a packet sent to the address may be delivered to multiple hosts more or less at the same time. IPv6 multicast addresses always start with the prefix FF00::/8.
• Anycast: An anycast address is a single address that is assigned to multiple hosts. This is similar to a multicast, except that a packet for the anycast address will be delivered to the one host that is nearest according to the routing protocol’s idea of distance. There is no special prefix for anycast addresses.

There is no such thing as a broadcast in IPv6. Ever. Any requirement for broadcasting is performed by a multicast instead.

IPv6 Address Configuration

For hosts to use IPv6 addresses, an IPv6 protocol stack must be installed. This likely means that you will need to upgrade your router IOS to provide IPv6 support. Then you can choose one of four options for address assignment.

To understand the address assignment choices better, we need to examine the concepts of stateful versus stateless configuration and the EUI-64 address format.

In IPv6, we can use DHCP to assign IP addresses just like in IPv4. The admin must set up the server with a scope of IPv6 addresses to hand out. The mechanisms used to discover and assign addresses are a little different, but the net result is the same. This is called stateful addressing, where the DHCP server keeps track of what hosts have been assigned what IPv6 address—in other words, the state of the host DHCP-wise.

There is another option for dynamic addressing in IPv6 called stateless autoconfiguration. This feature allows a host to choose and configure an address for itself. The host that wants an address learns what the /64 network prefix is on the local link, then appends its MAC address (in a special 64-bit format called EUI-64), thus generating a 128-bit IPv6 address that is unique to that host because it incorporates the unique MAC of the host.

The EUI-64 format is not so difficult to understand. We simply take the 48-bit MAC address and put a special pattern, FFFE, after the first 24 bits (the six OUI characters), followed by the rest of the six hex characters in the host MAC. The only trick is that according to IPv6 rules, the seventh bit in an EUI-64 address must be 1, which identifies that the burned-in MAC address has been modified. This is a little confusing, to be sure, but you can relax because the host determines and configures its EUI-64 address all by itself, if you tell it to. Here’s what an EUI-64 address conversion looks like:

Original MAC:

00-15-C5-CB-42-2B

Original MAC in binary:

00000000-00010101-11000101-11001011-01000010-00101011

7th bit = 0

Change 7th bit to 1:

00000010-00010101-11000101-11001011-01000010-00101011

EUI-64 MAC now:

02-15-C5-CB-42-2B

EUI-64 Address = </64 net_prefix>:0215:C5FF:FECB:422B

So, back to the four choices. The following really simplifies the options:

• Static configuration: The administrator chooses and assigns a static IPv6 address to the host NIC. It is the admin’s responsibility to choose an address that will function and be valid in the network to which the host is connected.
• Static configuration using EUI-64: The administrator manually configures the address with the local /64 network prefix followed by the host’s MAC in EUI-64 format.
• Dynamic configuration using DHCP to assign 128-bit address: The host is set to obtain its address from DHCP, and the DHCP server is set up to hand out IPv6 addresses from a scope.
• Dynamic configuration using stateless autoconfiguration with EUI‑64: The host is set to obtain its address automatically, but the DHCP server either does not exist (which works fine by the way), or if it does, it only informs the host of the /64 local network prefix.

IPv6 Router Configuration

Assuming your IOS provides IPv6 support, giving it an IPv6 address is really easy. The command is carried out at the interface configuration prompt:

interface fastethernet 1/0
ipv6 address 2001:AB00:00FF:1::/64 eui-64

Notice the eui-64 switch; this tells the router to figure out its own EUI-64 address to follow the /64 prefix provided. Without that, you must provide a full 128-bit address in the command.

To verify your configuration, use the show ipv6 interface command at the interface configuration prompt. The following is a sample output (with different addresses applied). You can see multiple addresses in use by the interface for global unicast, link-local, and multiple multicast groups:

Router#show ipv6 interface
  Serial1/0 is up, line protocol is up
    IPv6 is enabled, link-local address is FE80::A8BB:CCFF:FE00:D200
    Global unicast address(es):
      2001:1:33::3, subnet is 2001:1:33::/64 [TENTATIVE]
    Joined group address(es):
      FF02::1
      FF02::1:FF00:3
      FF02::1:FF00:D200
    MTU is 1500 bytes
    ICMP error messages limited to one every 100 milliseconds
    ICMP redirects are enabled
    ND DAD is enabled, number of DAD attempts: 1
    ND reachable time is 30000 milliseconds
  Router#

IPv6 Features

IPv6 has a couple features that you should keep in mind:

• IPsec: Support for IPsec is built in for IPv6; this means that every packet can be protected by IPsec transport on every IPv6 host if so configured.
• Mobility: IP mobility is built in, but obviously not mandatory because some hosts are not mobile.

• Fixed header size: The IPv6 header is fixed at 40 bytes or 320 bits. Figure 3.20 (in the next section) shows the IPv6 header.

  FIGURE 3.20 The IPv6 header.

• ICMP for IPv6 has changed, adding new functionality: One example of the new tricks it has learned is path MTU (PMTU) discovery: Before transmitting a packet, a host can send an ICMP message to learn what the smallest maximum transmission unit (MTU) on any link is between the sender and the destination. Then, the host sends packets that are no larger than that value. This clever trick relieves routers of having to fragment and reassemble packets over a small-MTU link, which can be a real performance hog. According to RFC 1981, hosts not using PMTU will transmit packets at the minimum IPv6 link MTU, which is actually quite small and likely to be inefficient.
• IPv6 makes extensive use of Router Solicitation (RS) and Router Advertisement (RA) messages: These are multicast messages to the addresses FF02::1 and FF00::2, respectively. The RS is sent from a host to all routers on the link as a multicast, and the RA message is sent from a router to all hosts on the link, also as a multicast. This is one way that the hosts learn whether DHCP is supported on the link, and possibly the DHCP server address.

The IPv6 Header

As mentioned in the preceding section, the IPv6 header is fixed at 40 bytes (320 bits) in length. Figure 16.11 shows the header fields and their sizes, and this section identifies what the fields are for.

The Version field identifies the IP version of this packet; for IPv6, obviously the version will be 6.

The Traffic Class field is where quality of service (QoS) marking for Layer 3 can be identified. In a nutshell, the higher the value of this field, the more important the packet. Your Cisco routers (and some switches) can be configured to read this value and send a high-priority packet sooner than other lower ones during times of congestion. This is very important for some applications, especially VoIP.

The Flow Label field is a number that identifies this packet as one of a flow of packets in a stream from sender to receiver; a good example is a VoIP call. It’s best for VoIP if all the packets in a given call get sent along exactly the same path to the receiving phone, so that they arrive in the same order they were sent. The flow label is one mechanism that IPv6 routers can use to keep track of different application flows and try to make sure that all the packets within a flow get treated the same way.

The Payload Length field indicates how big the payload of this packet is; it can be variable, so the router needs to know where the packet is supposed to end. That way it knows if anything went missing. This is especially important because there is no header checksum, as there used to be in IPv4.

The Next Header field takes over the Options header functions in IPv4. Short codes for extension headers are listed in the Next Header field, and additional information is appended in additional headers after the primary IPv6 header. All of this is designed to speed up the routing of IPv6 packets by preserving the size and content of the primary header, so it can be routed in the “fast switching” path of the router.

The Hop Limit field is a cool one: Whereas in IPv4 there was a TTL field that limited the life of a packet to 255 hops. (The IPv4 TTL value typically starts at 255 and is decremented by at least 1 as a packet is processed by a router. If it reaches 0, the packet is dropped. This prevents the packet from being endlessly misrouted around the Internet, although it could be misrouted up to 255 hops.) IPv6 is smarter: The Hop Limit value is set to the actual number of hops the packet will go through to reach its destination. This hop information comes from the IPv6 routing protocols. The Hop Limit is still decremented by 1 at each router, but the more accurate value means that the packet can’t be misrouted even by one hop.

The Source and Destination Address fields are self-explanatory; remember that the full 128-bit address for each is listed.

IPv6 Transition Strategies

Clearly, things are moving toward IPv6. The U.S. government once specified that all federal agencies must deploy IPv6 by 2008; then it was pushed back, ultimately to 2012. The process, though, is not going to affect every single host in these large networks overnight. Cisco wants you to be aware of their strategies for the transition to using IPv6 while still maintaining IPv4 functionality.

The easiest IPv6 transition choice is called dual stack. Dual stacking means that the host (router, PC, printer, and so on) runs both the IPv4 and IPv6 protocol stacks and can send and receive both types of packets, probably (but not necessarily) on the same interface. The drawbacks here are the additional load on the host and whether an IPv6 stack for that device is available (your old router might not be able to run IPv6).

Tunneling mode creates a tunnel for one protocol through another. You can picture taking an IPv6 packet from the head office, encapsulating it inside an IPv4 packet to transition across the provider network, then decapsulating it on the other side and forwarding the IPv6 packet into the remote branch office. This is known as a 6-to-4 tunnel; these tunnels can be either automatic or manual. 6-to-4 tunnels have a special address range of 2002::/16. Other tunneling strategies include the following:

• Teredo tunneling: Named after a particularly ugly species of marine wood-boring clam that makes tunnels in wood, this technology encapsulates IPv6 packets in IPv4 UDP datagrams for routing through the IPv4 network (usually the Internet). Its chief benefit is that it can operate from behind NAT devices. It is considered a “last resort” transition strategy, meaning that you should implement IPv6 natively instead, if possible.
• ISATAP (Intra-Site Automatic Tunnel Addressing Protocol) tunneling: This technology uses the IPv4 network (again, this would usually be the Internet) as a virtual NBMA data link layer. IPv6 link layer addressing is derived dynamically from IPv4 addresses, allowing dynamic neighbor discovery on top of IPv4 in addition to simple routability. ISATAP is a native capability in most Windows operating systems, Linux, and most Cisco IOS versions.

Translation means taking an IPv6 packet, removing the IP header, and replacing it with an IPv4 header that approximates the original IPv6 information as much as possible.

Translation is usually associated with a NAT router, and sometimes is known as NAT-PT (for Protocol Translation). What happens here is that the IPv6 packet header is removed and replaced with an IPv4 header (or vice versa), effectively changing from one protocol to the other. The big issues with NAT-PT are latency, performance loading, and the loss of header information in the translation process.

You need to know IPv6 configuration for your test; they may or may not ask you to actually do it (in a sim), but you definitely need to be able to recognize if the configuration they show you is valid.

Review Questions

1. Which of the following are alternate representations of the decimal number 227? Choose two.

   • A. 0x227
   • B. 11100011
   • C. 0x143
   • D. 0xE3
   • E. 11100110

2. Which of the following are alternate representations of 0xB8? Choose two.

   • A. 10110100
   • B. 10111111
   • C. 10111000
   • D. 184
   • E. 0x184

3. You have been asked to create a subnet that supports 16 hosts. What subnet mask should you use?

   • A. 255.255.255.252
   • B. 255.255.255.248
   • C. 255.255.255.240
   • D. 255.255.255.224

4. Given the mask 255.255.254.0, how many hosts per subnet does this create?

   • A. 254
   • B. 256
   • C. 512
   • D. 510
   • E. 2

5. You are a senior network engineer at True North Technologies. Your boss, Mr. Martin, asks you to create a subnet with room for 12 IPs for some new managers. Mr. Martin promises that there will never be more than 12 managers, and he asks you to make sure that you conserve IP address space by providing the minimum number of possible host IPs on the subnet. What subnet mask will best meet these requirements?

   • A. 255.255.255.12
   • B. 255.255.255.0
   • C. 255.255.240.0
   • D. 255.255.255.240
   • E. 255.255.255.224

6. Your boss, Duncan, does not seem to be able to grasp subnetting. He comes out of a management meeting and quietly asks you to help him with a subnetting issue. He needs to divide the Class B address space the company uses into six subnets for the various buildings in the plant, while keeping the subnets as large as possible to allow for future growth. What is the best subnet mask to use in this scenario?

   • A. 255.255.0.0
   • B. 255.255.248.0
   • C. 255.255.224.0
   • D. 255.255.240.0
   • E. 255.255.255.224

7. You have purchased several brand-new Cisco routers for your company. Your current address space is 172.16.0.0 /22. Because these new routers support the ip subnet zero command, you realize you are about to gain back two subnets that you could not use with the old gear. How many subnets total will be available to you once the upgrades are complete?

   • A. 4
   • B. 2
   • C. 32
   • D. 62
   • E. 64

8. Which of the following are true about the following address and mask pair: 10.8.8.0 /24? Assume that all subnets are available. Choose all that apply.

   • A. This is a Class B address.
   • B. This is a Class A address.
   • C. This is a Class C address.
   • D. 16 bits were stolen from the host field.
   • E. 24 bits were stolen from the host field.
   • F. The default mask for this address is 255.0.0.0.
   • G. The mask can also be written as 255.255.255.0.
   • H. The mask creates 65,536 subnets total from the default address space.
   • I. Each subnet supports 256 valid host IPs.
   • J. Each subnet supports 254 valid host IPs.

9. Indy and Greg have configured their own Windows 8 PCs and connected them with crossover cables. They can’t seem to share their illegally downloaded MP3 files, however. Given their configurations, what could be the problem?

   Indy’s configuration:

   IP: 192.168.0.65

   Mask: 255.255.255.192

   Greg’s configuration:

   IP: 192.168.0.62

   Mask: 255.255.255.192

   • A. Indy is using a broadcast ID for his IP.
   • B. Greg is using an invalid mask.
   • C. Indy’s IP is in one of the zero subnets.
   • D. Greg and Indy are using IPs in different subnets.

10. You are given an old router to practice for your CCNA. Your boss, Dave, has spent a lot of time teaching you subnetting. Now he challenges you to apply your knowledge. He hands you a note that says the following:

    “Given the subnetted address space of 192.168.1.0 /29, give the E0 interface the first valid IP in the eighth subnet. Give the S0 interface the last valid IP in the 12th subnet. The zero subnets are available. You have 10 minutes. Go.”

    Which two of the following are the correct IP and mask configurations? Choose two.

    • A. E0: 192.168.1.1 255.255.255.0
    • B. E0: 192.168.1.56 255.255.255.248
    • C. E0: 192.168.1.57 255.255.255.248
    • D. S0: 192.168.1.254 255.255.255.0
    • E. S0: 192.168.1.95 255.255.255.248
    • F. S0: 192.168.1.94 255.255.255.248

11. The following questions are part of a Subnetting SuperChallenge. This monster question will stretch your subnetting skills, especially if you give yourself a time limit. Start with 10 minutes and see if you can get down to 5.

    The Vancouver Sailing Company has four locations: a head office and three branch offices. Each of the branches is connected to the head office by a point-to-point T1 circuit. The branches have one or more LANs connected to their routers. The routers are called Main, Jib, Genoa, and Spinnaker. The company has been assigned the 172.16.0.0/20 address space to work within.

    Your task is to choose the correct IP address and mask for each interface, based on the information provided. Remember that no IP address may overlap with any address in another subnet, and that the required number of hosts for each subnet will affect your decision as to which address to use.

    Here are the known IP configurations for the routers:

    Main:

    S0/0:172.16.0.1 /30

    S0/1:172.16.0.5 /30

    S0/2:172.16.0.9 /30

    Fa1/0:172.16.4.1 /23

    Fa1/1:172.16.6.1 /23

    Jib:

    S0/0: Connects to Main S0/0

    Fa1/0: 172.16.8.33/27

    Fa1/1: 30 hosts needed

    Genoa:

    S0/0: Connects to Main S0/1

    Fa1/0: 172.16.8.129/26

    Fa1/1: 100 hosts needed

    Fa2/0: 100 hosts needed

    Fa2/1: 172.16.13.0/24.

    Spinnaker:

    S0/0: Connects to Main S0/2

    Fa1/0: 500 hosts needed

    Choose the correct IP and mask assignments for each router:

    • A. Jib Fa1/1: 172.16.8.62/27
    • B. Jib Fa1/1: 172. 16.8.64/27
    • C. Jib Fa1/1: 172.16.8.65/28
    • D. Jib Fa1/0: 172.16.8.65/27
    • E. Jib Fa1/1: 172.16.8.65/27
    • F. Genoa S0/0: 172.16.0.2/30
    • G. Genoa S0/0:172.16.0.6/30
    • H. Genoa Fa1/1:172.16.12.1/26
    • I. Genoa Fa1/1:172.16.12.1/25
    • J. Genoa Fa2/0:172.16.12.129/24
    • K. Genoa Fa2/0:172.16.12.129/25
    • L. Genoa Fa2/1:172.16.12.193/25
    • M. Genoa Fa2/1:172.16.13.1/25
    • N. Genoa Fa0/2:172.16.13.1/24
    • O. Spinnaker S0/0: 172.16.0.10/30
    • P. Spinnaker S0/0: 172.16.0.12/30
    • Q. Spinnaker Fa1/0: 172.16.13.0/23
    • R. Spinnaker Fa1/0: 172.16.14.0/23
    • S. Spinnaker Fa1/0: 172.16.14.1/23

12. Which of the following is the best summary statement for the following range of networks?

    192.168.1.0 /24–192.168.15.0 /24

    • A. 192.168.1.0
    • B. 192.168.1.0 255.255.240.0
    • C. 192.168.1.0 0.0.15.0
    • D. 192.168.1.0 255.255.248.0
    • E. 192.168.0.0 255.255.240.0

13. Which of the following is the best summary statement for the following range of networks?

    192.168.24.0 /24–192.168.31.0 /24

    • A. 192.168.24.0 255.255.240.0
    • B. 192.168.24.0 /28
    • C. 192.168.24.0 /21
    • D. 192.168.0.0 /27

14. Which of the following networks are included in the summary 172.16.0.0 /13? Choose all that apply.

    • A. 172.0.0.0 /16
    • B. 172.16.0.0 /16
    • C. 172.24.0.0 /16
    • D. 172.21.0.0 /16
    • E. 172.18.0.0 /16

15. What are the advantages of route summarization? Choose three.

    • A. Ensures job security for network admins because of difficulty of configuration
    • B. Reduces routing update traffic overhead
    • C. Reduces the impact of discontiguous subnets
    • D. Reduces CPU and memory load on routers
    • E. Identifies flapping interfaces
    • F. Hides network instability

16. Which of the following is a valid IPv6 address format?

    • A. G412:AFFA:2001:0000:0000:0000:0000:0001
    • B. 2001:8888:EEEE:1010:0000:0000:0000:0001
    • C. 2001::8888::1
    • D. 2010:2112:5440:1812:1867

17. Which of the following is a valid IPv6 unicast address format?

    • A. 2001:8888:EEEE:1010:0000:0000:0000:0001
    • B. FF00:0000:0000:0002:00CO:00A8:0001:0042
    • C. 2001:8888::2FFE::00A8
    • D. FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF

18. Which of the following are valid IPv6 address formats for the same address? Choose three.

    • A. 2001:0000:0000:0200:0222:0000:0000:0001
    • B. 2001:0000:0000:02:0222:0000:0000:0001
    • C. 2001:0:0:200:222:0:0:1
    • D. 2001::200:222::1
    • E. 2001:0:0:200:222::1

19. Which of the following is a valid IPv6 unicast address?

    • A. FF00:2112:1812:5440::1
    • B. 1812:2112:5440:1
    • C. 255:255:255:255:255:255:255:255:255
    • D. None of the above

Answers to Review Questions

1. Answers B and D are correct. Answer A in decimal would be 551. Answer C in decimal would be 323. Answer E in decimal is 230.
2. Answers C and D are correct. Answer A in hex is 0xB4. Answer B in hex is 0xBF. Answer E is simply an attempt to trick you—the correct decimal answer is incorrectly expressed as a hex value.
3. Answer D is correct. A will only support 2 hosts; B only 6, and C only 14. Watch out for the minus 2 in the host calculation! Answer C creates 16 IP addresses on the subnet, but we lose 2—one for the network ID and one for the broadcast ID.
4. Answer D is correct. The mask 255.255.254.0 gives us nine 0s at the end of the mask; 29 – 2 = 510. Answer A is checking to see if you missed the 254 in the third octet because you are used to seeing 255. Answer B does the same thing plus tries to catch you on not subtracting 2 from the host calculation. Answer C tries to catch you on not subtracting 2, and Answer E is the increment of the given mask that you might pick if you were really off track.
5. Answer D is correct. Disregarding for the moment the possibility that Mr. Martin might be wrong, let’s look at the requirements. He says make room for 12 managers, and make the subnets as small as possible while doing so. You need to find the mask that has sufficient host IP space without making it bigger than necessary. Answer A is invalid; 12 is not a valid mask value. Remember, a mask is a continuous string of 1s followed by a continuous string of 0s. In Answer B, the mask is valid, but it is not correct. This mask has eight 0s at the end, which, when we apply the formula 28 – 2 gives us 254 hosts. That makes more than enough room for the 12 managers, but does not meet the “as small as possible” requirement. Answer C has the correct mask value in the wrong octet. That mask gives us eight 0s in the fourth octet, plus another four in the third octet; that would give us 4094 hosts on the subnet. Answer E gives us 30 hosts per subnet, but that only meets half the requirement. This mask does not provide the minimum number of hosts.
6. Answer C is correct. The default mask for a Class B is 255.255.0.0. Answer C extends that mask by three bits, creating eight subnets (23 = 8). Although we only need six of them, we have to use the mask that creates eight because the next smaller mask would only create four, and that isn’t enough. Answer A is incorrect because it is the default mask for a Class B and not subnetted at all. Answers B and D are incorrect because although they create sufficient subnets, they do not maximize the number of hosts per subnet and so are not the best answer. Answer E uses the correct mask in the wrong octet.
7. Answer E is correct. With ip subnet zero enabled, all 64 subnets created by the mask in use become available. Answers A, B, and C are not even close and are simply distracters. Answer D wants to catch you by subtracting the zero subnets.
8. Answers B, D, F, G, H, and J are correct. Answers A and C are incorrect because this is a Class A address. Answer E is incorrect because only 16 bits were stolen. Answer I is incorrect because it does not subtract the two IPs for the network ID and broadcast ID.
9. Answer D is correct. With that mask, the increment is 64. Greg is in the first subnet, and Indy is in the second. Without a router between them, their PCs will not be able to communicate above Layer 2. Answer A is incorrect; the broadcast ID for Indy would be .63. Answer B is incorrect; nothing is wrong with the mask. Answer C is incorrect; the zero subnets are the first and last created, and Indy is in the second subnet. The question does mention the zero subnets, so we can use them, and in any case Windows 8 fully supports them.

10. Answers C and F are correct. This is an increment question. The increment here is 8, so you should start by jotting down the multiples of 8 (those are all the network IDs), and then noting what 1 less than each of the network IDs is (those are the broadcast IDs). From there, it is easy to find what the first and last IPs in each subnet are. (Remember that Dave says we can use the zero subnets.)

    The eighth subnet network ID is 192.168.1.56; the first valid IP is 192.168.1.57. The twelfth subnet network ID is 192.168.1.88; the last valid IP is 192.168.1.94. Answers A and D are incorrect because they do not use the subnetted address space Dave requested. Answer B is incorrect because it is a network ID. Answer E is incorrect because it is a broadcast ID.

11. SuperChallenge answers:

    1. Incorrect (same subnet as Fa1/0)
    2. Incorrect (network ID)
    3. Incorrect (not enough hosts)
    4. Incorrect (Fa1/0 IP already assigned)
    5. Correct
    6. Incorrect (wrong subnet—not on the same network as the connected interface on Main)
    7. Correct
    8. Incorrect (not enough hosts)
    9. Correct
    10. Incorrect (overlaps with Fa1/1)
    11. Correct
    12. Incorrect (overlaps with Fa2/0)
    13. Incorrect (wrong mask)
    14. Incorrect (no Fa0/2 interface on Genoa)
    15. Correct
    16. Incorrect (network ID)
    17. Incorrect (overlaps with Genoa)
    18. Incorrect (network ID)
    19. Correct
12. Answer E is correct. Answers A and C use incorrect syntax; Answer D uses the wrong mask. Answer B looks correct, but it does not use the correct network ID; the range should always start at a binary increment (in this case 0, not 1). (In other words, this is a case of “best answer.”) Note that the correct summary does include the 192.168.0.0/24 network as well (not just 192.168.1–15.0/24). This is intended to confuse and distract you!
13. Answer C is correct. Answer A uses the wrong mask and summarizes more than the specified networks. Answer B subnets instead of summarizes. Answer D uses the wrong address and mask.
14. Answers B, D, and E are correct. The networks in Answers A and C are out of the range, which is 172.16.0.0 through 172.23.0.0.
15. Answers B, D, and F are correct. Answer A might have an element of truth, but Cisco does not have much of a sense of humor. Answer C is incorrect because discontiguous subnets are a real problem if you intend to summarize. Answer E is incorrect; route summarization does not identify but rather hides the effects of flapping interfaces.
16. Answer B is correct. IPv6 addresses must have (or at least indicate, perhaps with ::) eight sets of four valid hex characters. Answer A is wrong because G is not a valid hex character. Answer C is wrong because it uses the :: notation twice, which is invalid. Answer D is wrong because it uses only five sets.
17. Answer A is correct. IPv6 addresses must have eight sets of four valid hex characters. Answer B is wrong because it starts with FF, which indicates a multicast address, not a unicast. Answer C is wrong because it uses :: twice, which is invalid. Answer D is wrong because there are only seven sets.
18. Answers A, C, and E are correct. These are the same address, represented in three valid notations: A is not truncated, C has dropped leading 0s, and E has compressed the contiguous all-zero groups with the ::. Answer B is wrong because it drops trailing 0s, not leading 1s. D is wrong because it uses the :: twice, which is invalid.
19. Answer D is correct. None of these is a valid unicast format. Answer A is an IPv6 multicast (starts with FF00/8). Answer B has only four sets instead of eight. Note that if there had been a double colon before the last 1, it could have been correct. Answer C uses the decimal 255 to confuse you; it could have been correct except that there are nine sets.

What Next?

If you want more practice on this chapter’s exam topics before you move on, remember that you can access all of the Cram Quiz questions on the CD. You can also create a custom exam by topic with the practice exam software. Note any topic you struggle with and go to that topic’s material in this chapter.

© 2024 Pearson Education, Pearson IT Certification. All rights reserved.

800 East 96th Street, Indianapolis, Indiana 46240

sale-70-410-exam    | Exam-200-125-pdf    | we-sale-70-410-exam    | hot-sale-70-410-exam    | Latest-exam-700-603-Dumps    | Dumps-98-363-exams-date    | Certs-200-125-date    | Dumps-300-075-exams-date    | hot-sale-book-C8010-726-book    | Hot-Sale-200-310-Exam    | Exam-Description-200-310-dumps?    | hot-sale-book-200-125-book    | Latest-Updated-300-209-Exam    | Dumps-210-260-exams-date    | Download-200-125-Exam-PDF    | Exam-Description-300-101-dumps    | Certs-300-101-date    | Hot-Sale-300-075-Exam    | Latest-exam-200-125-Dumps    | Exam-Description-200-125-dumps    | Latest-Updated-300-075-Exam    | hot-sale-book-210-260-book    | Dumps-200-901-exams-date    | Certs-200-901-date    | Latest-exam-1Z0-062-Dumps    | Hot-Sale-1Z0-062-Exam    | Certs-CSSLP-date    | 100%-Pass-70-383-Exams    | Latest-JN0-360-real-exam-questions    | 100%-Pass-4A0-100-Real-Exam-Questions    | Dumps-300-135-exams-date    | Passed-200-105-Tech-Exams    | Latest-Updated-200-310-Exam    | Download-300-070-Exam-PDF    | Hot-Sale-JN0-360-Exam    | 100%-Pass-JN0-360-Exams    | 100%-Pass-JN0-360-Real-Exam-Questions    | Dumps-JN0-360-exams-date    | Exam-Description-1Z0-876-dumps    | Latest-exam-1Z0-876-Dumps    | Dumps-HPE0-Y53-exams-date    | 2017-Latest-HPE0-Y53-Exam    | 100%-Pass-HPE0-Y53-Real-Exam-Questions    | Pass-4A0-100-Exam    | Latest-4A0-100-Questions    | Dumps-98-365-exams-date    | 2017-Latest-98-365-Exam    | 100%-Pass-VCS-254-Exams    | 2017-Latest-VCS-273-Exam    | Dumps-200-355-exams-date    | 2017-Latest-300-320-Exam    | Pass-300-101-Exam    | 100%-Pass-300-115-Exams    |