First things first. This is an excellent book. It is also by far the best book on its subject. Those are the first, simplest, and most important things to understand about it.
Before explaining what makes it so good, let's get the table of contents out of the way:
Part 1. Introduction and TCP/IP
2. The Transport Layer: TCP and UDP
Part 2. Elementary Sockets
3. Sockets Introduction
4. Elementary TCP Sockets
5. TCP Client-Server Example
6. I/O Multiplexing: The select() and poll() Functions
7. Socket Options
8. Elementary UDP Sockets
9. Elementary Name and Address Conventions
Part 3. Advanced Sockets
10. IPv4 and IPv6 Interoperability
11. Advanced Name and Address Conversions
12. Daemon Processes and 'inetd' Superserver
13. Advanced I/O Functions
14. Unix Domain Protocols
15. Non-Blocking I/O
16. ioctl() Operations
17. Routing Sockets
20. Advanced UDP Sockets
21. Out-of-Band Data
22. Signal-Driven I/O
24. IP Options
25. Raw Sockets
26. Datalink Access
27. Client-Server Design Alternatives
Part 4. XTI: X/Open Transport Interface
28. XTI: TCP Clients
29. XTI: Name and Address Functions
30. XTI: TCP Servers
31. XTI: UDP Clients and Servers
32. XTI Options
34. XTI: Additional Functions
Appendix A. IPv4, IPv6, ICMPv4, ICMPv6
Appendix B. Virtual Networks
Appendix C. Debugging Techniques
Appendix D. Miscellaneous Source Code
Appendix E. Solutions to Selected Exercises
A. Function Prototypes
B. Miscellaneous Source Code (all source code is available for download)
C. Solutions to Selected Exercises
Understanding why the book is as good as it is requires an understanding of what it does: (1) it serves as a tutorial for learning sockets programming, (2) it serves as an API reference, and (3) it serves as a guide to alternative strategies for network programs. It is not an easy thing to address these three disparate goals at the same time. The way Stevens does it is through his method of presentation.
The lowest-level building block around which Stevens structures his book is the individual function call. For each call (or minor variations on a single call), he provides the C prototype, and then, in text, explains what the function does, what it's arguments are for, and then provides a small C program that demonstrates it in action (all of the sample programs can also be downloaded from the web). These function-level building blocks are arranged into related sets, each of which is a chapter in the book. Each chapter has a wrapper that explains the basic concepts behind the functions in that chapter, and some review exercises at the end. The chapters in turn build on each other, with the most basic ones at the beginning and the more difficult ones towards the end.
The chapters do more, however, than just explain how the functions work, they also present different approaches to structuring socket programs. The basic problem in structuring a socket program is how to handle multiple connections. Choices include iterative vs. concurrent, multi-process vs. single-process, threaded vs. multiplexed. Stevens, in the process of teaching the reader the individual function calls, provides the reader with examples of all of these types of programs, along with a discussion of their relative strengths and weaknesses. I don't know if I can say enough in favor of Stevens' choice to include this material, or enough about the quality of his coverage of it.
Now some caveats. First, I have mixed feelings about the presentation of error handling. Stevens' coverage in the text is excellent, but the sample programs have a tendency to exit on error rather than demonstrate recovery. Also, the XTI coverage is thin; only about 120 pages of this 1,000 page book are about XTI. Finally, Stevens absolutely assumes that the reader knows how to program in C, knows general UNIX programming, and how to use Unix development tools (or at least has some other source from which to learn them). If you don't know C programming, you want to get Kernighan & Ritchie's "The C Programming Language". If you don't know about general UNIX programming, get Stevens' "Advanced Programming in the UNIX Environment". If you don't know the tools, I know of many books, but unfortunately none that I would particularly recommend.
In closing, whatever the caveats, this is clearly a five-star programming book. If you need to write socket programs, it can save you untold amounts of grief. Writing network programs that are efficient, fast, and robust is far from trivial, and you can think of the thousand pages in this book as a thousand ways to avoid a thousand mistakes. While it expensive, it paid for itself for me in the first hour, and every hour since has been a dividend - if only all my investments had worked out this well...
Note - this book is listed as volume one of a two volume set, but for network programming, the first volume stands by itself quite well. The second volume is a grab-bag of material on pipes, message queues, mutexes, locks, semaphores, shared memory, and remote procedure calls. For network programming proper, the first volume is all you need.