Enhanced descriptions from Syndetics:

TCP/IP Illustrated , an ongoing series covering the many facets of TCP/IP, brings a highly-effective visual approach to learning about this networking protocol suite.

TCP/IP Illustrated, Volume 2 contains a thorough explanation of how TCP/IP protocols are implemented. There isn't a more practical or up-to-date bookothis volume is the only one to cover the de facto standard implementation from the 4.4BSD-Lite release, the foundation for TCP/IP implementations run daily on hundreds of thousands of systems worldwide.

Combining 500 illustrations with 15,000 lines of real, working code, TCP/IP Illustrated, Volume 2 uses a teach-by-example approach to help you master TCP/IP implementation. You will learn about such topics as the relationship between the sockets API and the protocol suite, and the differences between a host implementation and a router. In addition, the book covers the newest features of the 4.4BSD-Lite release, including multicasting, long fat pipe support, window scale, timestamp options, and protection against wrapped sequence numbers, and many other topics.

Comprehensive in scope, based on a working standard, and thoroughly illustrated, this book is an indispensable resource for anyone working with TCP/IP.

Table of contents provided by Syndetics

• 1 Introduction
• Introduction
• Source Code Presentation
• History
• Application Programming Interfaces
• Example Program
• System Calls and Library Functions
• Network Implementation Overview
• Descriptors
• Mbufs (Memory Buffers) and Output Processing
• Input Processing
• Network Implementation Overview Revisited
• Interrupt Levels and Concurrency
• Source Code Organization
• Test Network
• 2 Mbufs
• Memory Buffers: Introduction
• Code Introduction
• Mbuf Definitions
• mbuf Structure
• Simple Mbuf Macros and Functions
• m_devget and m_pullup Functions
• Summary of Mbuf Macros and Functions
• Summary of Net/3 Networking Data Structures
• m_copy and Cluster Reference Counts
• Alternatives
• 3 Interface Layer
• Introduction
• Code Introduction
• ifnet Structure
• ifaddr Structure
• sockaddr Structure
• ifnet and ifaddr Specialization
• Network Initialization Overview
• Ethernet Initialization
• SLIP Initialization
• Loopback Initialization
• if_attach Function
• ifinit Function
• 4 Interfaces
• Ethernet: Introduction
• Code Introduction
• Ethernet Interface
• ioctl System Call
• 5 Interfaces
• SLIP and Loopback: Introduction
• Code Introduction
• SLIP Interface
• Loopback Interface
• 6 IP Addressing
• Introduction
• Code Introduction
• Interface and Address Summary
• sockaddr_in Structure
• in_ifaddr Structure
• Address Assignment
• Interface ioctl Processing
• Internet Utility Functions
• ifnet Utility Functions
• 7 Domains and Protocols
• Introduction
• Code Introduction
• domain Structure
• protosw Structure
• IP domain and protosw Structures
• pffindproto and pffindtype Functions
• pfctlinput Function
• IP Initialization
• sysctl System Call
• 8 IP: Internet Protocol
• Introduction
• Code Introduction
• IP Packets
• Input Processing: ipintr Function
• Forwarding: ip_forward Function
• Output Processing: ip_output Function
• Internet Checksum: in_cksum Function
• setsockopt and getsockopt System Calls
• ip_sysctl Function
• 9 IP Option Processing
• Introduction
• Option Format
• ip_dooptions Function
• Record Route Option
• Source and Record Route Options
• Timestamp Option
• ip_insertoptions Function
• ip_pcbopts Function
• Limitations
• 10 IP Fragmentation and Reassembly
• Introduction
• Code Introduction
• Fragmentation
• ip_optcopy Function
• Reassembly
• ip_reass Function
• ip_slowtimo Function
• 11 ICMP: Internet Control Message Protocol
• Introduction
• Code Introduction
• icmp Structure
• ICMP protosw Structure
• Input Processing: icmp_input Function
• Error Processing
• Request Processing
• Redirect Processing
• Reply Processing
• Output Processing
• icmp_error Function
• icmp_reflect Function
• icmp_send Function
• icmp_sysctl Function
• 12 IP Multicasting
• Introduction
• Code Introduction
• Ethernet Multicast Addresses
• ether_multi Structure
• Ethernet Multicast Reception
• in_multi Structure
• ip_moptions Structure
• Multicast Socket Options
• Multicast TTL Values
• ip_setmoptions Function
• Joining an IP Multicast Group
• Leaving an IP Multicast Group
• ip_getmoptions Function
• Multicast Input Processing: ipintr

Excerpt provided by Syndetics

Introduction This book describes and presents the source code for the common reference implementation of TCP/IP: the implementation from the Computer Systems Research Group (CSRG) at the University of California at Berkeley. Historically this has been distributed with the 4.x BSD system (Berkeley Software Distribution). This implementation was first released in 1982 and has survived many significant changes, much fine tuning, and numerous ports to other Unix and non-Unix systems. This is not a toy implementation, but the foundation for TCP/IP implementations that are run daily on hundreds of thousands of systems worldwide. This implementation also provides router functionality, letting us show the differences between a host implementation of TCP/IP and a router. We describe the implementation and present the entire source code for the kernel implementation of TCP/IP, approximately 15,000 lines of C code. The version of the Berkeley code described in this text is the 4.4BSD-Lite release. This code was made publicly available in April 1994, and it contains numerous networking enhancements that were added to the 4.3BSD Tahoe release in 1988, the 4.3BSD Reno release in 1990, and the 4.4BSD release in 1993. (App sourceB describes how to obtain this source code.) The 4.4BSD release provides the latest TCP/IP features, such as multicasting and long fat pipe support (for high-bandwidth, long-delay paths). {{Fig 1.1}} (p. 4) provides additional details of the various releases of the Berkeley networking code. This book is intended for anyone wishing to understand how the TCP/IP protocols are implemented: programmers writing network applications, system administrators responsible for maintaining computer systems and networks utilizing TCP/IP, and any programmer interested in understanding how a large body of nontrivial code fits into a real operating system. Organization of the Book We take a bottom-up approach to the TCP/IP protocol suite, starting at the data-link layer, then the network layer (IP, ICMP, IGMP, IP routing, and multicast routing), followed by the socket layer, and finishing with the transport layer (UDP, TCP, and raw IP). Intended Audience This book assumes a basic understanding of how the TCP/IP protocols work. Readers unfamiliar with TCP/IP should consult the first volume in this series, Stevens 1994, for a thorough description of the TCP/IP protocol suite. This earlier volume is referred to throughout the current text as Volume 1. The current text also assumes a basic understanding of operating system principles. We describe the implementation of the protocols using a data-structures approach. That is, in addition to the source code presentation, each chapter contains pictures and descriptions of the data structures used and maintained by the source code. We show how these data structures fit into the other data structures used by TCP/IP and the kernel. Heavy use is made of diagrams throughout the text - there are over 250 diagrams. This data-structures approach allows readers to use the book in various ways. Those interested in all the implementation details can read the entire text from start to finish, following through all the source code. Others might want to understand how the protocols are implemented by understanding all the data structurestand reading all the text, but not following through all the source code. We anticipate that many readers are interested in specific portions of the book and will want to go directly to those chapters. Therefore many forward and backward references are provided throughout the text, along with a thorough index, to allow individual chapters to be studied by themselves. The inside back covers contain an alphabetical cross-reference of all the functions and macros described in the book and the starting page number of the description. Exercises are provided at the end of the chapters; most solutions are in Appendix A to maximize the usefulness of the text as a self-study reference. Source Code Copyright All of the source code presented in this book, other than Figures 1.2 and 8.27, is from the 4.4BSD-Lite distribution. This software is publicly available through many sources (Appendix B). All of this source code contains the following copyright notice: Acknowledgments We thank the technical reviewers who read the manuscript and provided important feedback on a tight timetable: Ragnvald Blindheim, Jon Crowcroft, Sally Floyd, Glen Glater, John Gulbenkian, Don Hering, Mukesh Kacker, Berry Kercheval, Brian W. Kernighan, Ulf Kieber, Mark Laubach, Steven McCanne, Craig Partridge, Vern Paxson, Steve Rago, Chakravardhi Ravi, Peter Salus, Doug Schmidt, Keith Sklower, Ian Lance Taylor, and G. N. Ananda Vardhana. A special thanks to the consulting editor, Brian Kernighan, for his rapid, thorough, and helpful reviews throughout the course of the project, and for his continued encouragement and support. Our thanks (again) to the National Optical Astronomy Observatories (NOAO), especially Sidney Wolff, Richard Wolff, and Steve Grandi, for providing access to their networks and hosts. Our thanks also to the U.C. Berkeley CSRG: Keith Bostic and Kirk McKusick provided access to the latest 4.4BSD system, and Keith Sklower provided the modifications to the 4.4BSD-Lite software to run under BSD/386 V1.1. G.R.W. wishes to thank John Wait, for several years of gentle prodding; Dave Schaller, for his encouragement; and Jim Hogue, for his support during the writing and production of this book. W.R.S. thanks his family, once again, for enduring another "small" book project. Thank you Sally, Bill, Ellen, and David. The hardwork, professionalism, and support of the team at Addison-Wesley has made the authors' job that much easier. In particular, we wish to thank John Wait for his guidance and Kim Dawley for her creative ideas. Camera-ready copy of the book was produced by the authors. It is only fitting that a book describing an industrial-strength software system be produced with an industrial-strength text processing system. Therefore one of the authors chose to use the Groff package written by James Clark, and the other author agreed begrudgingly. We welcome electronic mail from any readers with comments, suggestions, or bug fixes: tcpipiv2-book@aw.com . Each author will gladly blame the other for any remaining errors. Gary R. Wright Middletown, Connecticut W. Richard Stevens Tucson, Arizona November 1994 020163354XP04062001 Excerpted from TCP/IP Illustrated: The Implementation by Gary R. Wright, W. Richard Stevens All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Author notes provided by Syndetics

Gary R. Wright has worked with TCP/IP for more than eight years. He is President of Connix, a Connecticut-based company providing Internet access and consulting services.

We are deeply saddened to learn of the death of noted author W. Richard Stevens . His passing is obviously a tremendous loss for the technical community, but it is a personal one for us as well. Rich was both a gifted colleague and a valued friend who will be greatly missed. We extend our sympathies to his family.

Obituary from the Arizona Daily Star :

STEVENS, W. Richard , noted author of computer books died on September 1. He is best known for his "UNIX Network Programming" series (1990, 1998, 1999), "Advanced Programming in the UNIX Environment" (1992), and "TCP/IP Illustrated" series (1994, 1995, 1996). Richard was born in 1951 in Luanshya, Northern Rhodesia (now Zambia), where his father worked for the copper industry. The family moved to Salt Lake City, Hurley, New Mexico, Washington, DC and Phalaborwa, South Africa. Richard attended Fishburne Military School in Waynesboro, Virginia. He received a B.SC. in Aerospace Engineering from the University of Michigan in 1973, and an M.S. (1978) and Ph.D. (1982) in Systems Engineering from the University of Arizona. He moved to Tucson in 1975 and from then until 1982 he was employed at Kitt Peak National Observatory as a computer programmer. From 1982 until 1990 he was Vice President of Computing Services at Health Systems International in New Haven, CT, moving back to Tucson in 1990. Here he pursued his career as an author and consultant. He was also an avid pilot and a part-time flight instructor during the 1970's.

He is survived by his loving wife of 20 years, Sally Hodges Stevens; three wonderful children, Bill, Ellen and David; sister, Claire Stevens of Las Vegas, NV; brother, Bob and wife Linda Stevens of Dallas, TX; nieces, Laura, Sarah, Collette, Christy; and nephew, Brad. He is predeceased by his parents, Royale J. Stevens (1915-1984); and Helen Patterson Stevens (1916-1997). Helen lived in Tucson from 1991-1997, and Royale lived here in the early 1930's attending Tucson High School while his father was treated for TB at the Desert Sanitorium (now TMC). The family asks that in lieu of flowers, donations be made in Richard's name to Habitat for Humanity, 2950 E. 22nd Street, Tucson, AZ 85713. A memorial service for Richard will be held at St. Phillip's in the Hills Episcopal Church on Tuesday, September 7th at 12:00 noon. Following the service there will be a reception in the Murphy Gallery of the Church. Please wear colorful clothing to the service; Richard loved colors.

W. Richard Stevens was an acknowledged UNIX and networking expert and the highly-respected author of several books. He was also a sought-after instructor and consultant.

020163354XAB04062001