UNIX Network Programming: Networking APIs: Sockets and XTI; Volume 1 [Hardcover]

W. Richard Stevens (Author)

Book Description

Publication Date: January 15, 1998

49001-1 The only guide to UNIX network programming APIs you'll ever need! Whether you write Web servers, client/server applications, or any other network software, you need to understand networking APIS-especially sockets in greater detail than ever before. You need UNIX Network Programming, Volume 1, Second Edition. In this book, leading UNIX networking expert W. Richard Stevens offers unprecedented, start-to-finish guidance on making the most of sockets, the de facto standard for UNIX network programming-as well as extensive coverage of the X/Open Transport Interface (XTI). Stevens begins by introducing virtually every basic capability of TCP and UDP sockets, including socket functions and options, I/O multiplexing, and name and address conversions. He presents detailed coverage of the Posix.1g standard for sockets and the Posix threads. He also introduces advanced techniques for: *Establishing IPv4/IPv6 interoperability. *Implementing non-blocking I/O. *Routing sockets. *Broadcasting and multicasting. *IP options. *Multithreading. *Advanced name and address conversions. *UNIX domain protocols. *Raw sockets.Learn how to choose among today's leading client/server design approaches, including TCP iterative, concurrent, preforked and prethreaded servers. Master the X/Open Transport Interface, including XTI TCP clients and servers, name and address functions, options, streams and additional functions. The Internet/intranet revolution has dramatically increased the demand for developers with a sophisticated understanding of network programming APIs, especially sockets. One book contains all you need to know: UNIX Network Programming, Volume 1, Second Edition.

Editorial Reviews

Amazon.com Review

The classic programming text Unix Network Programming has been updated by author W. Richard Stevens to encompass three new volumes. There have been a few changes in the computing world since 1990 (the year the original was published), and Stevens has taken the opportunity to create a complete set of reference manuals for programmers of all skill levels.

The first volume, Networking APIs: Sockets and XTI, covers everything you need to know to make your programs communicate over networks. Stevens covers everything from writing your programs to be compatible with both Internet Protocol version 4 (IPv4) and IPv6, to raw sockets, routing sockets, User Datagram Protocol (UDP), broadcasting/multicasting, routing sockets, server internals, and more, plus a section covering Posix threads.

Stevens also notes compatibility issues with different operating systems so that readers can create code that is more portable, and he offers plenty of advice on how to make code more robust. --Doug Beaver

From the Back Cover

The only guide to UNIX network programming APIs you'll ever need!

Whether you write Web servers, client/server applications, or any other network software, you need to understand networking APIS—especially sockets in greater detail than ever before. You need UNIX Network Programming, Volume 1, Second Edition.

In this book, leading UNIX networking expert W. Richard Stevens offers unprecedented, start-to-finish guidance on making the most of sockets, the de facto standard for UNIX network programming—as well as extensive coverage of the X/Open Transport Interface (XTI).

Stevens begins by introducing virtually every basic capability of TCP and UDP sockets, including socket functions and options, I/O multiplexing, and name and address conversions. He presents detailed coverage of the Posix.1g standard for sockets and the Posix threads. He also introduces advanced techniques for:

• Establishing IPv4/IPv6 interoperability.
• Implementing non-blocking I/O.
• Routing sockets.
• Broadcasting and multicasting.
• IP options.
• Multithreading.
• Advanced name and address conversions.
• UNIX domain protocols.
• Raw sockets.

Learn how to choose among today's leading client/server design approaches, including TCP iterative, concurrent, preforked and prethreaded servers. Master the X/Open Transport Interface, including XTI TCP clients and servers, name and address functions, options, streams and additional functions.

The Internet/intranet revolution has dramatically increased the demand for developers with a sophisticated understanding of network programming APIs, especially sockets. One book contains all you need to know: UNIX Network Programming, Volume 1, Second Edition.

See all Editorial Reviews

Product Details

• Hardcover: 1009 pages
• Publisher: Prentice Hall PTR; 2nd edition (January 15, 1998)
• Language: English
• ISBN-10: 013490012X
• ISBN-13: 978-0134900124
• Product Dimensions: 9.3 x 7.4 x 1.7 inches
• Shipping Weight: 3.8 pounds
• Average Customer Review: 4.6 out of 5 stars  See all reviews (50 customer reviews)
• Amazon Best Sellers Rank: #330,159 in Books (See Top 100 in Books)
  • #20 in Books > Computers & Technology > Programming > APIs & Operating Environments > Unix

Most Helpful Customer Reviews

71 of 77 people found the following review helpful

3.0 out of 5 stars Good but overrated July 31, 2000

By Bryan McClendon

Format:Hardcover

The book is very good for touching on quite a few topics in Network programming and doing so in a concise way. However, when reading the book I often felt as if I wasn't learning socket programming so much as learning how to access Steven's personal API to socket programming. When Stevens introduces a new concept he will immediately afterwords introduce a wrapper function that he uses to do it 'correctly'. From then on he will continue to use this wrapper function throughout the rest of the book whenever he needs to use the stanard library function. In fact, in any 10 lines of source in the book it seems like there will be 7 wrapper functions. This of course makes it very hard to use the book as a reference unless you are resigned to using Steven's wrapper library in all of your projects. In several cases, when attempting to reference some concept I ended up flipping through several pages in different chapters to look up definitions and prototypes for these functions in different place, and then diging deeper into the function to decipher what was going on. All I really wanted was a quick answer to a specific question concerning a socket. I can't deny that what he ends up with is a nicely done system for working with sockets, but I don't feel a general programming text should take this approach. I'll be shopping for a different socket book to use as a desk reference.

17 of 17 people found the following review helpful

5.0 out of 5 stars One of Two Must-Have UNIX Books March 3, 2003

By Randy Given

Format:Hardcover

This is one of two must-have UNIX books ("UNIX Network Programming" and "Advanced Programming for the UNIX Environment"). After I had been using UNIX for a long time and was getting into more advanced UNIX programming about a decade ago, these two books were recommended. I checked around and made comparisons. Sure enough, I had to agree. I bought both of them and use them a lot, even when doing Windows programming.

As an example, I had to reference them again this weekend. I am using Visual Basic and C++ under Windows to connect some UDP/IP communications between applications. Once again, these books were indispensable (even after looking at online help, Google, Microsoft Knowledge Base and Experts-Exchange). Any Internet professional should have both of these books on their shelf.

24 of 26 people found the following review helpful

5.0 out of 5 stars THE book on its subject July 14, 2001

By Bowen Simmons

Format:Hardcover

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:

Preface

Part 1. Introduction and TCP/IP

1. Introduction

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

18. Broadcasting

19. Multicasting

20. Advanced UDP Sockets

21. Out-of-Band Data

22. Signal-Driven I/O

23. Threads

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

33. Streams

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

Bibliography

Index

Appendices

A. Function Prototypes

B. Miscellaneous Source Code (all source code is available for download)

C. Solutions to Selected Exercises

Bibliography

Index

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.