Internetworking with TCP/IP, Volume IIIdescribes the fundamental concepts of client-server computing used to build all distributed computing systems, and presents an in-depth guide to the Posix sockets standard utilized by Linux and other operating systems. Dr. Douglas E. Comer compares leading server designs, and describes the key tools and techniques used to build clients and servers, including Remote Procedure Call (RPC). The book contains examples of running programs that illustrate each approach.Comer introduces the client-server model and its software design implications; the role of concurrent processing and threads; the Socket API, and differences that impact Linux programmers. Understand the key algorithms and issues associated with client and server software design; then review three leading approaches: iterative, connectionless servers (UPD); and both iterative and concurrent connection-oriented servers (TCP). The book contains extensive coverage of threading, including a new chapter on using threads for concurrency; as well as coverage of single-threaded and multi-threaded concurrent servers. Comer introduces multi-protocol and multi-service services; reviews client concurrency; tunneling at the transport and application levels; and external data representation (XDR). He reviews RPC, distributed program generation, NFS concepts and protocol; Telnet; streaming media transport; and finally, techniques for avoiding deadlock and starvation in client-server systems.For everyone who wants to master TCP/IP and understand how the Internet works.

Douglas E. Comer is a professor at Purdue University where he teaches popular computer networking courses.

Preface The Linux operating system is soaring in popularity, and especially important in the networking community as the system for many servers. This new version of Volume 3, which uses Linux, is aimed at programmers who want to understand how to create networking applications. Broadly speaking, it examines the question, "How does application software use TCP/IP protocols to communicate across an internet?" The text focuses on the client-server paradigm, and examines algorithms for both the client and server components of a distributed program. It shows an implementation that illustrates each design, and discusses techniques including application-level gateways and tunneling. In addition, it reviews several standard application protocols, and uses them to illustrate the algorithms and implementation techniques. Although this volume can be read and used alone, it forms part of a larger picture completed by two other volumes in the series. Volume 1 considers the question "What is a TCP/IP internet?" Volume 2 examines the question, "How does TCP/IP software work?" It presents more details, examines working code, and explores greater depth than the first volume. Thus, although a programmer can learn to create network applications from Volume 3 alone, the other volumes can be used to provide a better understanding of the underlying technologies. This version of Volume 3 includes the latest technologies. For example, a chapter explains how a Linux program can use the POSIX thread facilities to create a concurrent server. The chapter on NFS discusses version 3, the version that is about to emerge in the Linux community. In addition, sections have been included to explain concepts behind programs like slirpthat provide Internet access over a dialup telephone connection without requiring each computer to have a unique IP address. Two chapters that stand out as especially timely concentrate on streamingand the associated technologies used to send audio and video across the Internet. Chapter 28 describes fundamental concepts such as the Real-time Transport Protocol (RTP), encoding, and jitter buffers. Chapter 29 shows an implementation of RTP that is used to receive and play MP3 audio. The code for all examples in the text is available online. To access a copy via the Web, look for Volume 3 in the list of networking books at location: http://www.cs.purdue.edulhomes/comer/netbooks.html To access the code via FTP, use location: ftp://ftp.cs.purdue.edu/pub/Xinu/TCPIP-vol3.linux.dist.tar.Z The text is organized as follows. Beginning chapters introduce the client-server paradigm and the socket interface that application programs use to access TCP/IP protocol software. They also describe concurrent processes and the operating system functions used to create them. Chapters that follow the introductory material discuss client and server designs. The text explains that the myriad of possible designs are not random. Instead, they follow a pattern that can be understood by considering the choice of concurrency and transport. For example, one chapter discusses a nonconcurrent server design that uses connection-oriented transport (e.g., TCP), while another discusses a similar design that uses connectionless transport (e.g., UDP). We describe how each design fits into the space of possible implementations, but do not try to develop an abstract "theory" of client-server interactions. Instead, we emphasize practical design principles and techniques that are important to programmers. Each technique has advantages in some circumstances, and each has been used in working software. We believe that understanding the conceptual ties among the designs will help the reader appreciate the strengths and ''weaknesses of each approach, and will make it easier to choose among them. The text contains example programs that show how each design operates in practice. Most of the examples implement standard TCP/IP application protocols. In each case, we tried to select an application protocol that would convey a single design idea without being too complex to understand. Thus, while few of the example programs are exciting, they each illustrate one important concept. This version of Volume 3uses the Linux socket mechanism (i.e., socket API) in all programming examples; two other versions of the text contain many of the same examples using Microsoft''s Windows Sockets interface and AT&T''s TLI interface. Later chapters focus on middleware. They discuss the remote procedure call concept and describe how it can be used to construct distributed programs. The chapters relate the remote procedure call technique to the client-server model, and show how software can be used to generate client and server programs from a remote procedure call description. The chapters on TELNET show how small details dominate a production program and how complex the code can become for even a simple, character-oriented protocol. The section ends with the two chapters on streaming transport described earlier. Much of the text concentrates on concurrent processing. Many of the concepts described may seem familiar to students who have written concurrent programs because they apply to all concurrent programs, not only network applications. Students who have not written concurrent programs may find the concepts difficult. The text is suitable for a single semester undergraduate course on "socket programming" or a beginning graduate-level course on distributed computing. Because the text concentrates on how to use an internet rather than on how it works, students need little background in networking to understand the material. No particular concept is too difficult for an undergraduate course as long as the instructor proceeds at a suitable pace. A basic course in operating systems concepts or experience with concurrent programming may provide the best background. Students will not appreciate the material until they use it first hand. Thus, any course should have programming exercises that force the students to apply the ideas to practical programs. Undergraduates can learn the basics by repeating the designs on other application protocols. Graduate students should build more complex distributed programs that emphasize some of the subtle techniques (e.g., the concurrency management techniques in Chapter 16and the interconnection techniques in Chapters 18and 19). We thank many people for their help. Members of the Internet Research Group at Purdue contributed technical information and suggestions to the original text. Michael Evangelists proofread the text and wrote the RTP code. Gustavo Rodriguez-Rivera read several chapters, ran experiments to test details, and edited Appendix 1. Dennis Brylow commented on several chapters. Christine Comer edited the entire text and improved both wording and consistency. Douglas E. Comer David L. Stevens July, 2000