standards

Even though this book was first published in 1995, it still serves as a useful research and reference guide to those involved in changing the TCP/IP protocol or the mathematical and simulation modeling of it. Most of the source code is included for the protocol and UDP is treated also, with Berkeley TCP/IP used as the protocol implementation. A brief introduction to descriptors and memory buffers is given in Chapter 1, along with a discussion of input processing. The authors treat memory buffers (Mbufs) in detail in Chapter 2. Four different types of Mbufs are used in the protocol, depending on the flag setting in the m_flags member of the header. The source code clearly illustrates the data structures used for the Mbufs. This is followed by a detailed discussion of the Mbuf macros and functions. This is followed in the next chapter with a discussion of the interface layer and the all-important sockaddr data structure. In addition, the system initialization procedures are treated very nicely. This is followed by a very informative overview of the Ethernet interface, with most of the source code omitted since it is hardware specific. The LANCE driver is discussed thoroughly in this chapter. Then, in the next chapter, the SLIP and loopback interfaces are discussed with a very effective diagram used to illustrate the device drivers. The authors do manage to spend a few helpful paragraphs on SLIP performance considerations.

Chapter 6 is a very detailed treatment of IP addressing, the most useful discussion being the one on the in_ifinit function. This is followed by a discussion of the data structures used in domains and group protocols, with the IP initialization and transport multiplexing discussion being of particular interest to me.

The next 3 chapters give an overview of the IP layer, with IP packet structures and processing, option processing, and fragmentation and assembly all given detailed treatments. The performance issues involved in computing checksums and data copying are discussed also. The treatment of timeout processing by the function ip_slowtimo, which is very important from a modeling perspective, was given a thorough treatment.

ICMP is discussed in Chapter 11, with an extensive table included of the ICMP message types and codes. The discussion on error processing was particularly useful. This is followed in Chapter 12 by a survey on how IP multicasting is implemented along with Ethernet multicast addresses. A brief discussion of performance issues involved with Ethernet cards not supporting perfect filtering is given.

IGMP is then taken up in the next chapter, with a good discussion given of the virtual interface table in IP multicasting given in the next chapter. The authors carefully discuss the difference between physical interfaces and tunnels.

The most useful discussion in the book for me was the one on sockets in chapters 15, 16, and 17. The code for the socket data structure is given and a very detailed overview of socket system calls is given. The discussion of the listen and accept system calls is very helpful in understanding the process by which TCP sets up a connection. A full description is given of each macro and function involved in socket buffer allocation and manipulation.

Tree routing tables are discussed in chapters 18, 19, and 20, with emphasis on the structure of the radix tree routing tables used by packets, the interface functions between the kernel and the radix tree functions, and the routing sockets used to exchange routing messages. The discussion is extremely detailed, and the authors take great care in explaining the relevant data structures and function calls used.

ARP is discussed in Chapter 21, with a useful diagram given illustrating the relationship between ARP and routing tables and interface data structures. The structure of the ARP packet when transmitted on an Ethernet channel is shown in detail. Most interesting was the discussion on the algorithm used to avoid ARP flooding.

Protocol control blocks are discussed in the next chapter, with detailed treatments of binding, connecting, and demultiplexing. The handling of ICMP errors with the in_pcbnotify function is surveyed, with a detailed diagram summarizing how ICMP errors are processed.

The actual UDP implementation is discussed in Chapter 23, and the authors show how checksumming is done in this protocol. This is followed naturally by a discussion of the TCP implementation in the next 6 chapters. The reader can clearly see the difference in complexity between UDP and TCP in terms of the number of function calls and lines of code. A complete listing of the statistics used in the tcpstat data structure is given along with a listing of the SNMP variables used in tcp group. The TCP state transition diagram, familiar from Volume 1 by Stevens is given here also. The discussion of the seven TCP timers is very detailed and very helpful to those involved in the modeling of TCP performance. In particular the discussion of the tcp_xmit_timer function, which updates the smoothed RTT estimator and the smoothed mean deviation estimator, is very well written. Retransmission timeouts, the occurrence of which is so important in performance analysis and network troubleshooting, is given ample treatment also. Most interesting was the discussion on determining when a segment should be sent, via the tcp_output function. Also, the reassembly mechanism with the tcp_reass function is discussed in great detail. The reader who needs to be a TCP expert should take away a thorough understanding of it when completing these chapters.

The book ends with a fairly detailed treatment of the BSD Packet Filter and raw IP.

Noticeably missing of course, because of its age, is a discussion of the different versions of TCP/IP currently implemented in Windows 2000, Sun Solaris etc, which are slightly different. The reader will have to consult the Web or modern books to get an understanding of these implementations.

I was always fascinated by the way computers were connected over the networks and communicated. Being a software programmer, I was looking for a book which could explain how the internet protocols work. TCP/IP Illustrated gave me an excellent and in-depth details of how TCP/IP is implemented with a unique line by line explanation of source code and clear diagrams. The book is an absolute must on every network programmer's book shelf and for anyone like me interested in getting closer look at the way TCP/IP functions.

If you want to know the internal mechanisms used to build an IP stack, and how the mechanisms are implemented, this is the book to refer to. The level of detail is very impressive. Although Vol.1 can be read as a text book, Vol.2 is really a reference book with a large quantity of code. It is very easy to read and well indexed (very important for a book of this nature). Simply put, it's one of the best TCP/IP implementation books I've encountered yet.