This is a 50 page chapter with a two page summary. I will try to reach a compromise with those two facts. The chapter begins with a metaphor about networks:
There are several network models. The one most commonly used was created by the International Organization for Standardization, now called ISO. (No it isn't an acronym, it is from the Greek word isos, meaning equal.) Their model is called the Open Systems Interconnect (OSI) Reference Model, so it is also called the ISO-OSI model.
I am starting with this model because it is the one you will run into the most, and it makes several things clear that others do not. Once you understand this model, you will have a general, powerful reference for examining and comparing networks. There is a lot more to it than I will tell you today, so just take a moment to breathe and we will dive in.
The seven layers of the model are usually written in a list, numbering the top as layer seven and the bottom as layer one.
Several mnemonic sentences exist to help us remember the proper order. I recommend "Please Do Not Throw Sausage Pizza Away", because this is in the correct numeric order (bottom to top, 1 to 7). If you want one that goes from top to bottom, try "All People Studying This Need Drastic Psychotherapy". On any certification test that covers this model, you MUST remember the correct order, the correct numbers, and the correct details for each layer.
The processes that happen in each layer usually communicate with processes in the next layer. Which way is next, up or down? It depends whether data is being passed out of the stack (down) or into it (up). Typically, a computer generates a request when an application (program) wants something that is on the network. The request starts at the top layer, and works down. The request is passed across the network (probably to a server) and the received request is passed up the layers on that computer. When a response is generated, the process reverses, going from layer 7, down to layer 1, and across the network. If that's confusing, play one of the videos below.
Our author uses a related but simpler network model to introduce the chapter: the TCP/IP model. It only has four layers, but they match the ISO-OSI model nicely. Consider the table below. The four layers of the TCP/IP model are shown next to the matching layers of the OSI model.
Dr. Andrews uses the TCP/IP model to explain where the network layers are engaged in a web page request. Imagine the diagram above as the request for a web page is being sent as a signal onto the Internet:
The author turns to IP addressing on page 385 with a discussion of IPv4 addresses. The problem with this kind of lesson is that there is a lot of background to know. Sip your choice of soft drink and follow along.
Since the TCP/IP protocol stack was invented with networking in mind, IP addresses contain two parts: one to identify the address of the network a host is on, and the other part to identify the host itself. Every network is assigned an IPv4 address which could be one, two, or three bytes, depending on the class of the network (A, B, or C). The remaining byte or bytes are typically used for hosts on networks. (There are other ways to do it as well. Variations will be discussed shortly.)
Each byte in an IP address will be a number in the range 0 through 255, expressed in base 10 (decimal notation). You will need to be able to convert decimal notation to binary notation and vice versa, by hand. No calculator. A method of doing so is presented below.
First, some decimal math, for reference. Numbers are written in a
positional notation: the value of a digit is
determined by its position. For example, consider the number
Some basic training in binary notation: a byte has eight bits. Each bit can be a digit in a binary number. Since we can only use 1s and 0s in binary notation, we either have (1) or don't have (0) the number of units represented by a position in the binary number.
To translate a binary number to decimal, just
add the values of each position in which there is a 1. For
example, 11010011 in binary. Begin to convert to decimal by making
the value chart for binary. The chart is easy to make: start with
1, and work to the left. The next place is 2. Each position is
worth twice the value of the position to its right. Don't count
by twos, multiply each time by two.
So, add 128 + 64 + 16 + 2 + 1 = 211. (Don't add the values of positions holding a zero.)
To convert from decimal to binary, try this.
Start with a decimal number: 156. Compare it to the binary
position table. Work from right to left like this. Can you
subtract 128 (first position value) from the number (156)? Yes.
Write down a 1 in the first position, and subtract.
Continue across the table. Can you subtract 64 from 28? No. Write
down a 0. Can you subtract 32 from 28? No. Write down a 0.
Can you subtract 16 from 28? Yes. Write down a 1, and do the math. 28 - 16 = 12.
Can you subtract 8 from 12? Yes. Write down a 1, and do the math. 12 - 8 = 4. 4 happens to be the value of the next position, so write down a 1, and fill the rest of the positions with 0s.
So, 156 decimal is 10011100 in binary. If you are working on a decimal number less than 256, an 8 position binary table is big enough. Larger numbers require a wider table.
There are five IP address classes you need to know. The first three classes can be described by the number of bytes assigned to the network portion of their addresses:
Class D and E addresses use portions of the fourth byte as well for network addressing. You may wish to know that only class A, B, and C addresses are in general use. Class D addresses are for multicasting, and class E addresses are for experimental use.
You can recognize the class of an address by memorizing the range of values that occur in the leftmost byte of addresses in that class.
You can do it that way, but it is painful. A better way to recognize the class of a given address is shown on page 7-5. The five classes of addresses are defined as limited to specific ranges within the first byte. The numeric ranges are hard to remember until you see a chart like the one on page 7-5 that explains the ranges have to do with the binary version of the first byte.
Reading from left to right, if the first bit (position 7, above) of the first byte is a zero, that byte must represent a number less than 128. This defines a class A address: the first byte must be 127 or less. Consider it this way:
So, if you can convert the first byte of an address to binary notation, you can tell the address class by the position of the first 0 in it.
Page 7-8 has a list of some specific addresses that have special meanings:
There is a general rule that you can't set the host bits of an address to all 1s or all 0s.The same is true for the network bits.
If you do not have an assigned network address, you could use any address scheme you wanted as long as you did not attach to the Internet. However, in reality, everyone wants or needs the Internet, so you should use a private address scheme, as shown in the chart on page 7-10.
Any address beginning with a 10, for example, is assumed to be a private address. This is the format used in a network I have some experience with. To access the Internet, traffic passes through a server that acts as a proxy, providing a shared connection with a registered address. That is, the proxy server has an actual registered Internet IP address, as well as a ten-dot address on our network. Our PCs send signals to the proxy server, which shares its connection to the Internet. It assigns a separate port number to each PC on our network, and marks our signals to the Internet with that port number. This makes it possible to track the senders and receivers of each incoming and outgoing message, while still using only one registered IP address.
The process the proxy server uses to convert addresses on our ten-dot network to addresses usable on the Internet is an example of Network Address Translation (NAT).
Private addressing is often done along with subnetting. Suppose your company has six divisions or locations, and logically needs six networks. Logically, you would want to be assigned six different network addresses (such as 220.127.116.11). Suppose, however, that you either cannot get or cannot afford licenses for six networks. Then you take the one network address that you do have and create six subnets. (Six, by the way, is not a magic number, it is just an example.)
Reasons for creating subnets:
Subnetting works by borrowing bits from the host portion of an address, and using those bits to identify subsections of your network. The use of borrowed bits only works because of subnet masks. A subnet mask tells hosts on a network which bits in an address are network address bits and which bits are host address bits. It does it by the use of 1s and 0s. (What else have we got?) Consider the table below:
Network devices read a mask to learn how to interpret addresses. Address positions marked by 1s in a mask are considered network address positions. Address positions marked by 0s in a mask are considered host address positions. Another way of saying this is that certain address bits are considered to be network address bits and the rest are considered host address bits. The actual method used involves Boolean math, but understanding it is not critical to understanding or using the concept. When a device reads an actual IP address, the rule from the subnet mask is applied, and the device understands which bits are for what address.
The following table shows the subnet masks that result when
borrowing 1, 2, and 3 bits of the host address. Note the first
example: by borrowing one bit, two subnets are theoretically
possible. That is, the subnet bit could be set to 1 or 0: two
possible subnets. However, as a general rule, subnet
numbers using all 1s and all 0s are not used, so borrowing one bit
will probably not yield any usable subnet addresses. This is why
the formula for number of subnets is :
Note that the subnet masks above do not match the standard masks from the previous table. The standard masks are classful masks, because they match the intended use of class address schemes. The masks above are classless, because they do not match any network class. Look at the subnet masks in binary. Even when a network is using subnetting, all subnet masks are a series of 1s followed by a series of 0s. The series of 1s always tells you which positions in addresses are network positions, and the series of 0s always tells you which positions in addresses are host positions. In the table above, I have marked some positions in red, indicating which bits mark the actual subnetworks. They are important in planning and managing subnets.
Be aware that routers on the Internet only use the network bits of an address for routing. Routers connecting subnets within a network must use the network, subnet, and host bits for routing. Host addresses may be reused from one subnet to the next, but not within a subnet.
Consider class C networks. Obviously, you cannot use
eight bits to define a subnet on a class C network: you only have
eight bits to define a host address to begin with, and you
must use some of them for the host address. You must
strike a balance between how many subnets you need
and how many hosts you may put on each subnet. Suppose an
administrator has decided to borrow 3 bits from the host byte for
subnets, leaving 5 bits for host addresses. To calculate how many
usable subnets are obtained when borrowing a specific number of
bits, use the formula above:
To calculate the number of hosts possible for each subnet, do the same calculation, except that for the value of N, you use the TOTAL number of host bits available in the address. For instance, if this were a class B address, and you were borrowing 3 bits from the third byte for subnet addresses, the remaining 5 bits in the third byte and the 8 bits in the fourth byte would give you 13 as the value of N. Some methods call the exponent M when calculating the possible hosts, but the math is the same.The author mentions that counting the number of network address bits is useful, but it is easy to make a mistake, A better way of observing the number of network bits is to use Classless Inter-Domain Routing (CIDR). CIDR is a router standard that simplifies the use of classless subnet masks. In the CIDR standard, IP addresses are followed by a slash and the decimal number of bits used in the network portion of the subnet mask.
An example of CIDR notation might be 18.104.22.168/24. This example shows a network address, 22.214.171.124. It is followed by a forward slash, and the number 24. The number 24 means that the subnet mask for addresses on this network uses 24 bits as network identifiers. This is the same thing as saying that the subnet mask for this network uses 3 bytes as network identifiers, which is the same thing as saying the subnet mask is 255.255.255.0. In the table below, the same network is described three ways. Each is telling us the same thing: IP addresses on this network hold network information in the first three bytes, and host information in the fourth.
When addresses are sent on networks that allow CIDR notation, they can include this helpful notation that is the equivalent of sending the subnet mask along with the address. This is particularly helpful in networks that use subnetting. In such cases, the number following the forward slash probably will not be a multiple of 8.
When I first started working in IT, the IP addresses used by equipment in my agency were often registered/global IP addresses, unique addresses that were assigned by a license from IANA. IP address ranges in the various classes are assigned by the Internet Assigned Numbers Authority (IANA). Ranges of addresses assigned within a given class are called class licenses. Once upon a time, this was done by one person. Now, IANA doles out licenses to Regional Internet Registries (RIRs), who assign them to Internet Service Providers (ISPs).
Most homes have no need of public facing addresses, and they are better off without them. Instead, they use private addresses, ranges that are reserved for networks that do not connect to the Internet. Say, what? Yeah, that didn't last long. If you are using private addressing in your home or business, you will also use Network Address Translation (NAT) through your ISP. You essentially borrow one of the ISP's registered addresses to send and receive traffic across the Internet. Here is a video to make it easier to understand:
Dr. Andrews presents a couple of pages on IPv6 addresses, which is more of an accomplishment than you might think. Explaining it in such a small space is remarkable.
Dr. Andrews gives us some terms that are used in IPv6 addressing (and some used in IPv4 as well):
Our friend, Linus Sebastian, would like to talk about IPv6 so let's give him a shot. This video discusses IP addressing, and touches on NAT, too.
The text explains that DNS is a system that takes advantage of
the fact that IP addresses are hard to remember, but domain names
are easier. If we assume that a network can be
given a domain name, and a computer can
be given a hostname, then it makes sense that we
used to have a server called crux.baker.edu. Machine called crux,
in the sub-domain baker, in the edu domain. This is an example of
a fully qualified domain name. It works on the
DNS system that everyone uses.
The text also wants you to know the major differences between UDP
and TCP, the two protocols used for delivery of most
transmissions. The TCP protocol operates on the
Transport layer, which makes this layer associated with the word reliable.
If a packet is lost or received in a damaged state, a replacement
copy of the packet is requested. This is one aspect of
reliable, guaranteed delivery.
The text offers a pair of related lists. First there is a list of protocols commonly used in the TCP/IP suite for specific purposes. Here are several examples,
Application Layer Protocols (upper 3 layers of the OSI model)
Transport layer protocols
As noted above, a simple test for whether a protocol under consideration is connection oriented or connectionless: if you are asked this question about a protocol, does its name start with a consonant or a vowel? UDP, IPX, and IP are connectionless. TCP, SPX, and NFS are connection-oriented.
The text discusses port numbers, telling us that numbers below 1024 are called well-known port numbers. A port number can be any number from 1 through 65535. Several port numbers are assigned to specific services through conventions established by ICANN. (A listing may be found in RFC 1700.) If you follow the link above to the list of ports used by specific services, you will find more information than is in your text. You will also find that although the text says that NNTP uses UDP, it also uses TCP.
Some references say ports 1024 through 65535 are Registered ports. Others say that 1024 through 49151 are the Registered ports, and that 49152 through 65535 are Dynamic ports.
The text mentions switches and hubs. You don't want a hub, and you probably won't find one in a store. Hubs have multiple ports (usually RJ-45 jacks). Any signal coming into a hub comes back out on all ports. Bad use of bandwidth. Now that you have that, Let's hear Linus on switches, WAPs, modems, and routers. You can stop watching after he explains hubs, unless you want to see a three year old minute and a half commercial.
The text presents about a page of types of servers you might find on a network. Be aware that the word "server" does not mean a computer. It means a service available on a network. All of the servers in Dr. Andrews' list could be running on one box. That's an extreme idea, but it could be done if one server-box is all you had.
There is brief discussion of network security devices, but it is not very educational. There is a short discussion of Ethernet cables with some terrible pictures. There are a few more filler concepts. We have already discussed the useful ones.
The last section of the chapter is about troubleshooting. Run through this section.