Customer Reviews

The Definitive Guide to Linux Network Programming (Expert's Voice)

5 star:		(3)
4 star:		(3)
3 star:		(1)
2 star:		(1)
1 star:		(0)

 

 

A very insteresting book. I would like to see a more advanced version of this book in the future. It covers the basics of TCP & UDP, and helps you in choosing a suitable design/protocol for your applications, and covers everything related to network programming including security, debugging... Excellent work!

I'm not sure about the "definitive" claim in the book's title. But after reading the book, I'm quite willing to grant that the authors have indeed done a thorough job. The book calls to mind the now classic series on Internetworking, by Comer and Stevens in the early 90s. If you've been in this game long enough, you know exactly what I mean. Of course, Comer and Stevens were looking at unix boxes hooked to the Internet.

But, as you can see in this book, linux network programming carries over very closely to those unix versions. And both use what is basically the same IPv4, despite the massive physical buildout of the Internet.

The book's code is unabashedly C. No cute user interface to trip over. It can test your knowledge of C quite well. Partly because the coding and handling of network calls is deliberately low level. Using the book's approach, you can get a fine grained appreciation of how to talk across the Internet. Higher level languages like Java and C# come with network libraries that deliberately hide a lot of this detail. Which is good for many applications. But sometimes you might need the performance and control that this book offers.

Skimpy coverage, the code compiles with a bazillion warnings, and for me at least the first client/server examples just plain don't work and don't provide useful enough error messages to figure out. It's not until you get to a much later chapter that you learn about debugging techniques that *might* help. This debugging information should either have been moved forward within the book, or should have been forward-referenced from the first example. Additionally the book repeats the same information over and over again, for instance in any example that calls for the use of the INADDR_ANY constant, the author explains what it stands for each and every time. This sort of repetition is simply not acceptable in a book fancying itself as somehow "definitive" yet only 300 or so pages. Furthermore, rather than covering ins and outs of actual network programming, far too much is devoted to the basics of various protocols (the first 20+% of the book), and/or security specifically (the last 20+% of the book). A better title for this book would be Linux Network Programming *Fundamentals*, and as such this would warrant 4 stars, maybe even 5 if it taught debugging earlier. As a *Definitive Guide* though it is a 2 at best; if you want truly definitive, albeit regarding Unix generally and not necessarily Linux, Stevens' "Unix Network Programming" series is the real deal.

Whether you just want to learn the concepts and practices that allow network programming to work or want to polish your skills in this area, The Definitive Guide to Linux Network Programming will serve you well. I have rarely seen a book about programming that managed to bridge the gap between newcomer and expert so well.

The authors clearly aimed this book for those who are programmers, yet they have made it accessible even to those who are not. Depending on how much you know about network programming, you can start at different points in the book. The authors kindly make suggestions in the introduction as to which sections are most relevant for those who are more expert already.

I was very impressed by the extensive amount of code that is included. In many cases, you will be able to program simply by using the examples in the book. That resource is nicely extended by two lengthy case studies that are intended to help you think your way through the process as well as to integrate the book's subjects. The first case study is for a networked chat application that is written in C++. The second case study looks at the many tricky security questions associated with any networked application.

The book is filled with guidelines and suggestions for when to favor which approaches among the many that Linux offers you. I was especially pleased to find out about many development and debugging tools that make the job easier.

Here's the book's structure:

Part One deals with the basics (networks, protocols, functions, socket programming, sessions and state). Part Two looks at design and architecture (emphasizing design decisions and development processes). Part Three is devoted to security.

Reading the book reminded me of what a great gift Linux is to us all in making it easier for us to use computer networks to communicate with one another. I kept shaking my head as I read the book trying to imagine how much more limited a book would have been that did not use Linux as its subject.

I thought that the discussions of security management were the best part of the book. They were clear, provided a good conceptual backdrop for the potential solutions, and made the solutions as simple as possible.

If you plan to do network programming with Linux, you owe it to yourself to read and apply this superb book!

This 13 chapter book sets high expectations in claiming to be a "definitive guide", but at 350 pages, of which about 20% is worked examples, perhaps a thorough introductory guide would be a better description. The text is deliberately designed in a modular fashion and is divided into three sections: Fundamentals, Design Architecture and Security. The introduction contains a good "What you should read" section that explains the book's structure and how to get the best out of it for the categories of beginner, novice, experienced or expert. This is followed by chapter summaries, so you can quickly identify how you can get the most out of this book and find sections of specific interest. I found the authors did a good job of presenting what could be a dry subject in an interesting style that should suit a broad range of readers. The commented C/C++ source code examples are conveniently available from the publisher's website, but annoyingly I found that the examples wouldn't build as provided.

Chapters 1 to 4 in the Fundamentals section cover Networks and Protocol theory, Network Functions, Socket Programming (datagram vs streaming) and Protocols, Sessions and State. Well explained sample code is presented beginning with the Functions chapter as the book moves into practical examples of Ethernet programming.

Chapters 5 to 9 in the Design Architecture section starts with a very interesting chapter examining the various strengths and weaknesses associated with some example client-server architectures including the Apache 2 Web Server, i.e. multiplexing, multiprocessing servers, single process per client vs the process pool approach and multithreaded servers. Guidance on which approach is best for your specific implementation is provided with the pros and cons summarised in a useful one page table. A chat program demonstrates the use of a custom protocol implementation in chapter 6, which is further developed in the case study in chapter 9, where 40 pages are allocated to describing in detail how this application is implemented in C++. Chapters 7 and 8 look at the various design decisions involved in designing a networked application, i.e. TCP vs UDP, custom application protocol vs established protocol, client-server architecture (two or three tier), thick, thin and modular clients and server considerations such daemonising, logging, privilege dropping and chroot jails. These latter security options are covered in greater detail in the Security section (chapters 10 to 13). The Debugging and Development Cycle is specifically covered in chapter 8. This chapter also covers a few tools that could prove useful development aids as well as providing some tips to ease development process, some of which are covered in more detail in the Security section.

Chapter 10 introduces secure communications using Tunnelling, PKI and OpenSSL, along with a client and server example. Authentification and Data Verification methods using the PAM library along with an in-depth look at PKI management code are covered in chapter 11. Chapter 12 covers common security problems and mitigation steps - useful tips that will help you avoid some common coding security vulnerabilities and finishes with a couple of overview paragraphs on the use of Flawfinder and Splint for security vulnerability code analysis.

The Security section is rounded out by an extensive worked PAM/PKI client & server example (10% of the book content), commencing at the design stage - reinforcing the philosophy that security must be considered at the start - not as a bolt on, with the worked example reinforcing material introduced earlier.

The 19 page appendix on IPV6 covers how to handle the expanded addressing provided by IPV6, how to port existing IPV4 applications to IPV6 and tips on how to create applications that will handle both IPV4 and IPV6.

The 15 page index is fairly comprehensive and there is the eBook version for easier searching if you think you'll be using this as a frequent reference book.

This is a straightforward walkthrough of developing network clients and servers in C on Linux. Though many of the same principles could be applied to Windows network programming.

The book starts off with a small chapter on architecture. It quickly becomes chapters of annotated code with a few illustrations thrown in. The text is well written and the the book is short enough to make that format workable.

The last section of the book is dedicated to security. Which I appreciate since C programming is so fraught with security problems.

I recommend this book to those looking to write basic network protocols with C. Though I think it should be said that using a wrapper C++ library, or some higher level applications language for network protocol work will be advisable.

This book gives a good general overview of network programming for the Linux operating system along with the C source code used for the implementation. Therefore, individuals who prefer to do network programming in PERL will have to find another book. It is written for the beginner to network programming, but could serve as a general reference for more seasoned network programmers. Due to the straightforward way in which the authors explain the ideas, the book can be rapidly assimilated by those readers who are pressed for time and need to get to the frontiers of the subject with little delay. I only read the first 7 chapters of the book, and so this review will be confined to these.

In chapter 1, the authors give an elementary and general overview of networks. All of the discussion is very easy to understand, and should be helpful for newcomers. In particular, the idea of a port is sometimes a source of confusion for those who are new to networking, sometimes viewing them as being hardware interfaces on network devices. They are rather virtual destinations, and allow a standardization of just what kind of network traffic can be passed to and from a node.

Chapter 2 is an introduction to socket functions, a `socket' being explained as an abstraction for network communication. The Linux operating system uses the Berkeley socket interface (over TCP/IP), and the basic network I/O functions and the notion of a `socket descriptor' are explained in detail. A client/server configuration is used to illustrate the function calls utilized in sockets. Address data structures, such as `sockaddr_in', `linger', and `servent', are discussed. The authors also address the need for specifying the network byte order, so as not have to deal with issues of just how numbers are represented on a particular machine. Code is given for a simple application consisting of a string transfer from server to client.

In chapter 3, the authors concentrate on how to transfer files between a client and server but over the (connectionless) UDP protocol using `datagram sockets.' The discussion clearly points out the differences between TCP/IP and UDP in client/server network communications when doing file transfer. A very brief discussion is given for error handling.

The authors go into more of the details of protocol architectures and methods. An important part of this discussion is the difference between `stateful' servers, which maintain information about the current connections with its clients, and `stateless' servers that do not. A fairly thorough discussion is given on the different methods for maintaining state in a server, using the concept of `sessions'. The role of the HTTP protocol in maintaining a session in a stateless server is outlined, along with the role of `session IDs' for this purpose. The authors also discuss how to maintain state on the client side, using cookies, hidden form variables, and URL parameters.

The next part of the book deals with design issues and decisions and how to develop network programs that function in the client-server environment. Explicit programs are given that illustrate multiplexing, forking, and preforking, the latter of which will alleviate somewhat the costs associated with creating child processes during the initialization of the application. The authors also discuss multithreading, and its advantages in performance versus its disadvantages in stability (due to its use of shared memory). They also give the usual cautions in the use of multithreading, such as the need for mutexes when using global variables shared among threads, and when dealing with servers that must maintain a large number of persistent connections. For readers in the scientific community, a very useful section on how to deal with large amounts of data using nonblocking sockets is given.

Only a cursory discussion is given of "thick" and "thin" clients in this part, probably since the book is about Linux-based network programming. In non-Linux environments, thin-client architectures have become very important in recent years. The authors do discuss issues from both the client-side and the server-side, such as the differences between `monolithic' and `modular' clients, and the use of daemons on network servers. The advantages for using `privilege dropping" are also outlined, this being used in Web server programming for binding ports, and in giving an application superuser status.

This book was very easy to understand and to-the-point. There are plenty of code examples that are relevant to the topics, and the best part is they work. Finding good information is one of the most difficult aspects of software development, so it is always refreshing to find a resource that is not driven by marketing hype or self-promoting "experts". Thanks guys!