Read an Excerpt
Chapter 1: Prelude to a Practical GuideThe Transmission Control Protocol/Internet Protocol (TCP/IP) suite, sometimes called TCP or IP, is often viewed as a maze of acronyms and jargon. Although I don't have a magic wand to make the terminology disappear, I hope to provide you with the tools that you need to understand what's going on behind the curtain. To help minimize confusion, I'll italicize the firs-t occurrence of new terms.
Before diving into a detailed look at the protocols, tools, and applications that make up TCP/IP we'll walk through some background information to help provide context for the later chapters. The rest of this chapter introduces layered protocols, describes TCP/IP in brief, gives an example of TCP/IP at work, discusses the organizations and methods involved in specifying TCP/IP provides some information about the development of the TCP/IP protocol on Linux, and discusses physical-layer issues.
Layered Protocols: A Description and History
In the beginning, custom written communications programs allowed one computer to talk to another. If you wanted to talk to a different computer, you had to write a new program to do so.
This approach could not scale past a very few computers. A similar situation occurred in the early days of European trains. Individual regions built their own rail systems without trying to match track sizes (called gauges) with neighboring systems. If you wanted to ship cargo or travel between two regions, you had to stop at one or more regional boundaries and change trains because the one you were on couldn't use the tracks for the new region. The first attempts to overcome this problem were proprietary protocols allowing computers from the same manufacturer to talk to one another. None of these protocols is in wide use today, but Unix-to-Unix Copy Program (UUCP) is similar in concept: a monolithic protocol that can be used only with another computer that understands UUCP Fortunately, UUCP is widely available instead of being locked up as a vendorspecific protocol. (Even more fortunately, UUCP is rarely used anymore and is implemented on top of TCP in most cases where it is used.)
The next stage of the protocol evolution was the layered protocol. In this model, the protocol is broken into layers arranged in a stack (rather like dishes in a cupboard). Each of these layers is comprised of one or more protocols, an unfortunate duplication of terminology. Every layer is meant to pass information vertically within the stack. Non-TCP/IP examples of layered protocols include eXtensible Name Service (XNS, the ancestor of the Novell protocol stack) and System Network Architecture (SNA, the IBM communications protocol).
Typically, layered protocols are discussed in terms of the OSI seven-layer model. Each layer is responsible for certain functions within the network (for example, the network layer addresses and routes packets, and the presentation layer encrypts and compresses data).
These different layers (and potentially different protocols at each layer) can be thought of like a set of several different games. Some of the games use the same kinds of things (such as laminated playing cards). Of all the games using cards, some use the same kind of deck (a standard 52-card deck, for example). Even those using a standard deck make up a wide variety of games (for example, poker, gin rummy, and solitaire), and you can't really mix the rules between them.
The data at any given layer is organized in much the same way as the data at airy other layer. A packet (a generic term for a blob of data at any layer) is composed of two parts, a header and a payload (or data), as shown in Figures 1.1 and 1.2...