This is a very extensive book on TCP/IP protocol implementation on BSD/Linux systems. For any one who is interested in involving in networking protocol software development, this book is a must read and also a reference. It deals with kernel implementation of protocols and user based socket APIs/ioctls in detail. I strongly recommend this book for any beginner or experience professional a like.

I knew that this book is good, but it is more than good. You can find here any IP - related information, explained from simple to complex in all aspects. The information I was trying to find from different sources (Wikipedia etc), is just concentrated in the book.

It is not so good than real steven's volume I. It has not been written by steven. But has a good review for TCP/IP stack.

This is a bible, sliced into 3 neat pieces to explain and demonstrate everything related to TCP/IP right from the 0's and 1's in the packet. It is something like a must have set of books for someone who really wants to know the basics of networking right from its foundations.

I bought this book because I was faced with having to port an application that uses BSD routing sockets and interface management ioctls to an operating system that doesn't support either of these features. The book contained enough information about these fairly obscure constructs that I was able to figure out what the mystery program was doing.

A source book for developers, and everyone interested in study the IP protocol and sorrounding protocols: a Packet Switching delivery service.

Interesting Programming topics:

* Jump Table (Figure 3.11, page 71) by which network device specific details are isolated from the Network Layer.

* Relationship between Network Packet Structures (in memory) and the Source code that manipulate them as in page 90-91: the Ethernet frame structure.

Interesting Protocol internal topics:

* Device driver modular diagrams as in page 101: Ethernet device driver.

* IP Packets with Option processing and how fragmentation is worked out (pages 210-216)

* The major and most important self-question and function of IP routers: "To Forward or Not To Foward" an IP Packet. A detail description of final destination and other decision topics: routing, fragmentation, reassembly, option processing (pages 217-300).

* ICMP: the Control Message protocol used by IP to exchange control and service information between nodes. Description of ICMP input processing (diagram and source code at pages 310-313), correction of meaning name "ping" (page 316), redirect processing.

* TCP Protocol: as a state dependant protocol (pages 802-994). Describes the state transition, initial state and final state hand-shake, and control timers (pages 817-847) including an interesting retransmission timeout computing formula (pages 831-847).

A source book for developers, and everyone interested in study the IP protocol and sorrounding protocols: a Packet Switching delivery service.

Interesting Programming topics:

* Jump Table (Figure 3.11, page 71) by which network device specific details are isolated from the Network Layer.

* Relationship between Network Packet Structures (in memory) and the Source code that manipulate them as in page 90-91: the Ethernet frame structure.

Interesting Protocol internal topics:

* Device driver modular diagrams as in page 101: Ethernet device driver.

* IP Packets with Option processing and how fragmentation is worked out (pages 210-216)

* The major and most important self-question and function of IP routers: "To Forward or Not To Foward" an IP Packet. A detail description of final destination and other decision topics: routing, fragmentation, reassembly, option processing (pages 217-300).

* ICMP: the Control Message protocol used by IP to exchange control and service information between nodes. Description of ICMP input processing (diagram and source code at pages 310-313), correction of meaning name "ping" (page 316), redirect processing.

* TCP Protocol: as a state dependant protocol (pages 802-994). Describes the state transition, initial state and final state hand-shake, and control timers (pages 817-847) including an interesting retransmission timeout computing formula (pages 831-847).

Want to really understand TCP/IP, this is the best text. Hands down.

This expands on where volume 1 leaves off. this is advanced ip topics, so get your seatbelt on.

I cannot fathom a guess as to how many times the books in this series have saved my in project work over the years. The only drawback with this series is that some publisher should endeavor to keep them up to date. Serious Unix system programmers must have copies of the complete series.

I bought this book shortly after finishing Volume 1. With volume 1, I found myself staying up late to read more, but volume 2 gets tiring after a while... it's literally a detailed analysis of every single line of networking code in the BSD 4.3 kernel. Although it's well worth the effort, I found myself reading no more than about 10 pages at a time (constantly flipping back, sometimes almost all the way to the beginning, to re-read something I hadn't quite absorbed the first time).

Difficulty aside, this book alone will honestly make you a TCP/IP guru - now that I've read volumes 1 and 2, the networking administrators where I work come to me with questions about issues they can't resolve. I'm literally comfortable saying that there's nothing I don't know about TCP/IP, and that's not a statement I'd make lightly (feel free to test me). But more than that, I learned a *lot* about writing good, solid code... in learning the networking stack as a whole, I was able to understand some higher-level software engineering concepts that had previously eluded me.

All in all, volume 1 is The Hobbit, and volume 2 is the Lord of the Rings - an oddysey not to be undertaken lightly, but from which you will emerge stronger and more powerful than ever before.

An elaborate description of network implementation and working of transport layer protocols. Like all of Richard Steven's books, this one too has a large number of code examples to explain the usage of
the data structures and the API used for writing networking applications. The book offers a great index for backreferencing.
Covers all important layer 3 and 4 protocols and the various services offered by them. The code examples provide an excellent first step for starting network programmers and a useful reference for the experienced.

I found vol 2 and 3 extremely helpful as a reference book, definitely recomended for learning the core of the tcp/ip system.

i started out trying to learn the basics of the ip stack,
insted this prompted me to buy vol 1 and 3 as well.

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.

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.

Again Stevens is on the real work in this book. My comment is simple; buy this book if you really like to be a IP guru.. If you startas a novice I advise you to buy the first volume of this book as well..