Slashdot Mirror

outanowhere writes "The author of the Philips webcams kernel module has thrown in the towel and quit providing the pwc and pwcx kernel modules which make using Philips-based USB cameras such as those from Logitech and Philips possible with Linux. According to the author, the last straw was when a kernel maintainer changed his pwc module to make using the binary-only pwcx compression module impossible. It is a victory for obsessive kernel-purists but a major loss for all Linux users."

Deunan writes "While poking around on the Internet, I discovered a DirectX front end for the classic The 7th Guest CD-ROM puzzle adventure. After some further searching, I stumbled across a more recent pitch for 7th Guest III: The Collector [apparently the game was in development in 2002/3, and there's an interview with designer Rob Landeros about it, but it seems to be stalled.] I was wondering what killed interest in it - are 'thinking' games just not popular anymore?"

Deunan writes "While poking around on the Internet, I discovered a DirectX front end for the classic The 7th Guest CD-ROM puzzle adventure. After some further searching, I stumbled across a more recent pitch for 7th Guest III: The Collector [apparently the game was in development in 2002/3, and there's an interview with designer Rob Landeros about it, but it seems to be stalled.] I was wondering what killed interest in it - are 'thinking' games just not popular anymore?"

Komawi writes "Greetings, On the night of march 11th my car was stolen (Mercedes Benz, I'm realy fond of that car!), but also my laptop with in it a wireless networkcard with the following MAC address: 00:30:BD:9C:BD:B2 Also a mobile phone was stolen, with IMEI number 351083531088913. If anyone has a way to locate these goods and by this I get back my car, a reward of 500 euros will be given! The goods were taken from Alkmaar, The Netherlands somewhere between 2004-03-11 23:00 and 2004-03-12 07:30. May the force be with you!"

John_Renne writes "One of the most well known scientists in the near history is Albert Einstein. Pictures of him can be found on allmost everything varying from lunchboxes to t-shirts and cartoons. On the other hand there's little knowledge of who Einstein really was and the human being behind the genius. This article tries to create a view of the inner Einstein. A nice read for everyone interested in the person inside the phenomenon."

Mike Bouma writes "Amiga`s CEO Bill McEwen announced in a keynote speech held prior to the AmiWest 2001 show that new consumer PPC motherboards, AmigaOS 4.0 PPC and also AmigaOS for x86 will ship by November 1. Furthermore the Amiga Digital Environment which offers full binary compatibility across CPU architectures and operating systems was being demonstrated at the show running on various handheld devices. In addition, Bill stated that Merlancia Industries has acquired the rights for the Amiga Multimedia Convergence Computer which was being worked on by the Amiga team under Gateway but was cancelled. Merlancia will release new PPC hardware soon after the AmigaOne launch. Their CTO is the infamous Amiga system designer Dave Haynie who designed many critical parts of the classic Amiga 2000, 3000 and 4000 desktop computers. "

EasyTarget writes, "TopClick aims to be a search engine that is very privacy respecting, no cookies, banner ads or other data harvesting. It uses a common protocol to the Google search engine that prevents session tracking or user identification. Is this the start of mainstream companies that view strong privacy as a 'product' in itself?"

After a bit of an absence, Arjen Laarhoven has returned with a stellar review, this time of Eric Greenberg's new book Network Application Frameworks. Click below if you are interested in the design and implementation of networks in combination with the applications that run on them. Network Application Frameworks author Eric Greenberg pages 406 publisher Addison-Wesley rating Useful i reviewer Arjen Laarhoven ISBN summary 9/10 Overview Network Application Frameworks (NAF) is about networks and the applications that utilize them. This seems like kicking in an open door. Maybe. Many people tend to forget that networks and applications are symbiotic entities that perform a wide variety of tasks to help people and companies to do their work efficiently and effectively.

People who develop network-aware applications mostly take the infrastructure on which their applications run for granted. Little thought is given to the amount of traffic their applications generate, and when performance problems arise, they go complaining to the network people that network performance stinks and that they should do something about it.

NAF presents an amazing amount of information about this and many other problems that arise in today's networked world. More importantly, it also provides information about how these problems can be avoided or solved. The book is roughly divided into 3 parts:

1. An introduction to the the concept of Network Application Frameworks
2. The TCP/IP protocol suite
3. Specific information about the technology that is in wide use today, with solutions that Microsoft, Novell and IBM provide. Also, technology that isn't very widely used but has a very big impact on the industry is discussed. A separate chapter about The Open Group's DCE (Distributed Computing Environment) is an example of this.

The most striking feature of this book is that it provides a reasonable level of detail without losing sight of the big picture. A lot of specific technologies are discussed, like TCP/IP, DCE/DFS, Java, object technology, CORBA, ODBC, COM, ActiveX, NetWare, SNA, CICS and a host of other alphabet soup. Again, all these things are discussed without losing sight of interoperability, performance, security and ease of use (for both the users and the administrators).

I thought myself to be a pretty knowledgable person about programming and the use of the network in applications. NAF made it painfully obvious that I'm not. That is to say, like many other programmers, I worked in a blissful ignorance with respect to the big picture. For example, writing a program using the UNIX sockets API is one thing, but developing an application with taking performance, security and the use of services like LDAP, NDS and the Windows NT directory services is a whole other story.

While this book is an eye-opener for the tech folks like myself, it is also very informative reading for network designers and IT managers. By reading and thinking about the information that is provided in NAF, people with different backgrounds are ``educated'' in thinking about networks and applications from a number of different perspectives. Exactly that is what is missing all too often in computer and network departments of companies today. An awareness of the big picture. I think that by reading this book, people from different backgrounds (programmers, network designers and managers) can appreciate the problems and talk to each other about the solutions to these problems.

What's in it for me? A whole lot. Depending on your background, I think you can learn a lot about networks, network topology, services, security and performance. Also, software technology like Java, CORBA, Directory Services (X.500, LDAP, NDS and the Windows NT Directory Services and Active Directory) is covered in considerable depth. A lot is said about legacy systems, with the most important example being the systems and network technologies from IBM (mainframes, SNA and CICS).

All these things are covered without losing sight of the fact that these different technologies can (and have to) be put together to provide a solution that works. Integration is the buzz-word these days, and not only integration of the obvious Windows and UNIX stuff, but also time-tested solutions and technology from Novell and IBM. With every discussion about a specific platform, be it Windows NT, NetWare or IBM's SNA, a lot of information is provided on why and how to integrate these different systems into a coherent whole.

What's good? NAF is a very readable book, without avoiding technical discussions when necessary. Every chapter begins with a ``mind map'' of the topics that are discussed. Although this was new to me, I found it a very helpful thing to get a comprehensive overview of the topics and their relationships.

At the end of each chapter is a summary of the things that are discussed, and a list of references is given to books and articles that go into more depth about a particular topic.

Technical discussions are clarified by a lot of illustrations. I think I saw W. Richard Stevens saying in an interview "If I can't make a picture, I don't understand it." How true. For example, the topic of security (public key cryptography and the workings of Kerberos) is not exactly a simple one. The illustrations accompanying the text add a lot to gain an understanding of the more complex ideas.

Another good thing I want to point out are Eric's considerations about proprietary technology. For example, we all know Microsoft is very good at locking customers into a MS-only solution. In discussing proprietary technologies Eric points out the risks and benefits of going with one vendor for a particular solution and forces the reader to think for himself about these issues based on the information provided. He certainly is a proponent of open technologies but without forgetting about the other solutions that are available.

The last chapter provides a condensed overview of practically all the topics that are discussed in more depth in the previous chapters. This is very helpful if you encounter an abbreviation or concept and you have forgotten what it exactly meant.

What's bad? IMHO, not much. You may not like relatively big proportion of Microsoft technology that is discussed (chapters 7, 8 and 9), but fact is that a lot of Windows stuff is in use, and that it's not going away, though how much we would like to.

The references to NT5 are kinda obsolete, but it's not Eric's fault that Microsoft changed the name of that OS (the book was published in November 1999).

With the current pace of change in the computer industry, some things are bound to have changed since the book was published. For example, I don't know if all the things about Windows 2000's Active Directory are actually implemented.

Conclusion All in all, I think that NAF is a very valuable book to read. I certainly learned a lot about the integration of networks and applications.

Everyone who works in the enterprise software business, be it as an adiministrator or developer, can gain a lot of insight and specific information by reading this book and thinking about it.

Table of Contents (abbreviated)

• Preface

• 1. What Is a Network Application Framework?
• 2. Core Network Application Framework Technologies
• 3. The TCP/IP Protocol Suite
• 4. IP Routing
• 5. Internet Protocol Version 6 (IPv6)
• 6. The Open Group Distributed Computing Environment (DCE)
• 7. Microsoft and WOSA
• 8. The NT4 Directory Service
• 9. NT5 Active Directory Services
• 10. Novell NetWare
• 11. IBM
• 12. Design Rule Summary

• Index

Links to Web pages related to Network Application Frameworks

• Seine Dynamics, Inc (The company of the author)
• Addison-Wesley's page on NAF

You can buy this book at Amazon.

ZeroTolerance writes "The FFII has set up a letter to the EU competition commisioner about the proposal for the introduction of a software patenting system similar to that in the US. Read more about it at swpat.ffii.org (in German) And sign the petition here (in English; German, French, Italian and Esperanto versions also available) " Trust me. You folks don't want the US style patents. Unless you have a silly lawsuit fetish.

Drizzeth writes "Today S.u.S.E. Linux 6.1 will be released, this is what's new: Kernel 2.2.5, XFree86TM 3.3.3.1, Support for all 3Dfx cards: Voodoo I + II (accelerated) Voodoo Rush (accelerated) Voodoo Banshee / Voodoo III (beta), KDE 1.1 with koffice, GNOME 1.0, Ghostscript 5.10, ijb (non-cacheing HTTP proxy server that filters contents as described in the configuration files), freeamp (MP3-Player), netbeans (Cross-plattform Java IDE, Demo) And lots of updates."

Rowan writes "I've written a longish (but nice, I hope) publication about various matters in the GNU Software Community. It ends with describing how important conflicts are to learn and discover errors. It's meant to be the first in a row and I think they'll all be worth the read. "

Rowan writes "I've written a longish (but nice, I hope) publication about various matters in the GNU Software Community. It ends with describing how important conflicts are to learn and discover errors. It's meant to be the first in a row and I think they'll all be worth the read. "

Arjen Laarhoven has taken some time to send in a review of W. Richard Stevens' book Unix Network Programming, Vol. 1. Obviously the first in a series, this is an updated version of the original, introduced in 1990. This book covers new concepts from the original, from multi-threading to IPv6, in addition to the rest of knowledge this tome contains. Click below to read more. UNIX Network Programming, 2nd Ed, Volume 1; Networking APIs: Sockets and XTI author W. Richard Stevens pages publisher Prentice-Hall, Inc. rating 10 reviewer Arjen Laarhoven ISBN 0-13-490012-X summary This new edition of UNIX Network Programming explains almost every detail of network programming on the UNIX platform thoroughly and clearly. New concepts which have become mainstream since the first edition of 1990, like multithreaded programs are explained, as are the mechanics of IPv4 and IPv6 interoperability which will become important in a few years.

When you start with UNIX programming, and have mastered the basics, the first thing most people want to try out is network programming (at least, I wanted to :-). A lot of people who work with UNIX or Linux have access to a networked environment, and work with networked applications and tools on daily basis. There are a lot of papers and tutorials on socket programming floating around on the Net, but these mostly describe the basic mechanics. In a very short time, you can create small client-server programs which work quite nice. But there is a lot more to UNIX network programming than just being able to open sockets and send data back and forth.

At this point, this new edition of UNIX Network Programming enters the scene. The material from the first edition (almost 9 years old now) is greatly expanded to describe todays standards and new additions to the UNIX environment, like multithreading and IPv4/IPv6 interoperability.

This new edition of UNIX Network Programming is split into 3 volumes, of which 2 are published (Volume 2 is "Interprocess Communications", and 3 will describe important networking applications which). The main reason for this split is that the topic of network programming has expanded much since 1990. Also, the individual topics are much more elaborately described than the first edition.

An important addition to this new edition is the use of multithreaded programs in addition to the fork and select implementation models. Multithreaded programs are a hot topic these days, as they make network programming easier in a lot of situations, and perform better on platforms with multiple processors.

Another important topic is the use of IPv6 and its interoperability with the current IPv4 standard. A great deal of information is provided about making programs protocol-independent. This will be an important part of network programming, when IPv6 becomes more mainstream.

The first edition of this book described more protocols than just TCP/IP. Now, almost 9 years later, TCP/IP is the clear winner of the battle with protocols like OSI and XNS. Also, the socket API for network programming has become the "de facto" standard. But the socket API is not the only one which is described. The last part of the book describes the XTI (the X/Open Transport Interface) networking API, which originated at SysV and is part of the X/Open Unix 98 specification. Some parts of the interface has provisions to accommodate these other protocols, and are mentioned where applicable, but the focus is on TCP/IP

Other nice things are the coverage of the low-level networking APIs, like the BPF (BSD Packet Layer Filter), the DLPI (Data Link Provider Interface) and the Linux (!) SOCK_PACKET interface. These 3 interfaces are mostly platform and/or OS dependent, so there is also information about the libpcap library (used in tcpdump, for example), which provides portable access to these low-level networking capabilities.

Not all the things described in UNP2V1 are available on all UNIX platforms, so some things will not work on the platform on which you are developing your network applications. But most UNIX vendors are hard at work to implement all the standards. Sun Solaris and DEC UNIX 4 are currently the most capable platforms in this respect. There is good information on the networking capabilities of Linux, and the Linux community is hard at work to let it adhere to the standards decribed in this book.

What's in it for me? If you are looking for more in-depth information about creating networking applications on the UNIX platform, UNP2V1 is for you. Not only descriptions of the various functions are provided, but things are explained thoroughly and often accompanied by example programs, which you can run and tinker with. Every chapter is ended by a section of exercises, with which you can test your understanding of the material covered in the chapter. Not only theoretical questions are asked, but a lot of exercises require you to compile, run and change the example programs and figure out what is happening because of the changes.

Instead of just describing the interfaces, there is also information provided on how the TCP/IP protocol works. Stevens has found it very enlightening to know some of the mechanics of the protocol, because you know what is going on "under the hood" and can track down problems very quickly. In some discussions, Stevens refers to his TCP/IP Illustrated series, which provide much more details on the complete TCP/IP protocol suite.

Debugging is a large part of the programming process, and network programming requires some additional tools to diagnose and solve problems in network applications. Stevens explains how to use tools like netstat, tcpdump, ifconfig and his own sock programs to help you debug your network applications.

Designing a network application (and especially servers) can be done in various ways. The most important concepts are the forking model, the select model and the use of multithreading. In a separate chapter, Stevens describes the pros and cons of the different models, illustrated by examples and performance measurements. This way, you can make an informed decision on how to design your network application.

What's Good? The first printing did not provide enough information in the captions of the example programs. Stevens goes through a number of revisions of a program, to include the information just covered. The problem was that you did not know if a program was not optimal or even buggy, unless you read the text. This has been changed in the new printings. Also, the first printing has a lot of typos, and some errors but these bugs have been fixed in the new printings. Stevens maintains a very detailed errata list, so you can debug your copy of UNP2V1 if necessary.

I think that you have to read through this book at least once to use it as a reference. This way, you know what is possible, and can look up the parts you want when you need it. This is not a bad thing IMHO, because you have to understand the basic concepts before you can do anything useful.

The information in the front and back of the cover help you to find important functions, macro's and datastructures quickly. Also, the index is very good.

I have heard people complaining there is no information provided on network programming using the Win32 platform. These people seem unable to read titles of books. Also, the standards described in this book are standards which are created by POSIX and X/Open, and the UNIX community itself. Therefore, it is highly unlikely that they will change radically in the future. Microsoft controls the Win32 API completely, and can do with it what they want.

What's bad? IMHO, nothing. I am aware that the book is not cheap, and that the split into multiple volumes also does not help to cut the price. But to find out this kind of information in a depth comparable with what is described in UNP2V1 yourself will cost huge amount of time (and in the case of a professional programmer, a lot of money). This review is about the contents of the books and the quality of information, and not about price.

Stevens keeps up-to-date errata on his home page, so when bugs or inconsistencies are discovered, you can find them quickly there. You can buy this book at Amazon.

Table of Contents (abbreviated) Part 1. Introduction and TCP/IP

• Chapter 1. Introduction
• Chapter 2. The Transport Layer: TCP and UDP

Part 2. Elementary Sockets

• Chapter 3. Sockets Introduction
• Chapter 4. Elementary Sockets
• Chapter 5. TCP Client-Server Example
• Chapter 6. I/O Multiplexing: The select and poll functions
• Chapter 7. Socket Options
• Chapter 8. Elementary UDP Sockets
• Chapter 9. Elementary Name and Address Conversions

Part 3. Advanced Sockets

• Chapter 10. IPv4 and IPv6 Interoperability
• Chapter 11. Advanced Name and Address Conversions
• Chapter 12. Daemon Processes and inetd Superserver
• Chapter 13. Advanced I/O Functions
• Chapter 14. Unix Domain Protocols
• Chapter 15. Nonblocking I/O
• Chapter 16. ioctl Operations
• Chapter 17. Routing Sockets
• Chapter 18. Broadcasting
• Chapter 19. Multicasting
• Chapter 20. Advanced UDP Sockets
• Chapter 21. Out-of-Band Data
• Chapter 22. Signal-Driven I/O
• Chapter 23. Threads
• Chapter 24. IP Options
• Chapter 25. Raw Sockets
• Chapter 26. Datalink Access
• Chapter 27. Client-Server Design Alternatives

Part 4. XTI: X/Open Transport Interface

• Chapter 28. XTI: TCP Clients
• Chapter 29. XTI: Name and Address Functions
• Chapter 30. XTI: TCP Servers
• Chapter 31. XTI: UDP Clients and Servers
• Chapter 32. XTI Options
• Chapter 33. Streams
• Chapter 34. XTI: Additional Functions

Appendix A. IPv4, IPv4, ICMPv4, and ICMPv6

Appendix B. Virtual Networks

Appendix C. Debugging Techniques

Appendix D. Miscellaneous Source Code

Appendix E. Solutions to Selected Exercises

Bibliography

Index

Links to Web pages related to UNIX Network Programming, Vol. 1

• W. Richard Stevens' home page
• Prentice-Hall's page on UNP2V1

Arjen Laarhoven has graciously provided the Slashdot community with a review of Advanced Programming in the Unix Environment. Basically, if your goal is guru-dom, then this book is for you, covering the a full range of systems programming. Check out the review below. Advanced Programming in the UNIX® Environment author W. Richard Stevens pages publisher Addison Wesley Publishing Company, Inc. rating 10/10 reviewer Arjen Laarhoven ISBN 0-201-56317-7 summary

If you want to learn how to make (systems) programs in Unix, this book is invaluable. Whether you are an experienced professional programmer coming from another environment such as Windows or Mac, or a college student who wants to make programs that run on Linux, *BSD and/or workstations at school, this book is for you, and is an excellent step in the direction of Unix guru-hood.

Today, things like graphics, object-oriented programming, Java, Perl and component-ware are highly valued, and sometimes with good reason. But more and more an important aspect of programming is neglected: systems programming. Getting as close to the underlying system as possible. I think that it is important for anyone interested in programming on a particular platform (and not only the Unix platform) to get at least a "nodding acquaintance" with the API of that underlying system. It gives you a valuable insight in how things are done, and enables you to make more intelligent design and implementation decisions in programming on a higher level. Also, it is real fun (IMHO) to really get down to the system (but this is not news to Linux hackers :-).

Advanced Programming in the UNIX® Environment (APUE) is a book that shows how to get close to the Unix system, while remaining portable across the different flavors of Unix. It does this with remarkable clarity. Anyone who knows books written by Stevens knows what I'm talking about. All his books are of very high quality. I own them all, except the first edition of UNIX Network Programming.

APUE is somewhat structured like a textbook on operating systems, unsurprisingly. It begins with an overview introduction of Unix, explaining some important basic concepts, and the standardization of Unix. See the table of contents at the end of this review.

There are three chapters with complete example applications, in which practically all the material in the preceding chapters is used in a real-world setting. These examples are completely worked out, explaining how and why certain things are done as they are.

The most striking thing about this book that it really explains the system calls and their relationships with other parts of the system, rather than just summing up system calls and leaving you in the dark about how, why and where to use them. Also, there are a lot of tables, diagrams and shell interaction transcripts that summarize and visualize the workings of the system calls and the programs that use them.

Although you can learn much by just reading, you really gain an understanding by really working with the material presented. A lot of complete code examples are given throughout the book, and Stevens invites, no urges you to compile, run and tinker with it. All the examples are available in a package which can be downloaded from Stevens' home page, ready to compile, run and modify.

What's in it for me? You can learn how to program in Unix by studying the manual pages and reading other people's code (which you should :-), but this book makes the learning curve much more smooth by providing an overview of the concepts and the relationships between them, before diving deep into the details.

An important aspect of Unix programming is portability. APUE contains many pointers on writing programs that are portable across different Unix systems, taking the SysV and BSD differences as a starting point. Also, APUE discusses standards as POSIX.1, XPG3 (now XPG4) and explains the differences between them where appropriate. The code examples are in ANSI (ISO) C. An important part of C is the Standard I/O Library, and APUE provides a whole chapter on this, comparing the Standard I/O Library with the low-level file I/O systems calls, and the relationship between them.

The most important feature of this book (IMHO) are the exercises at the end of each chapter. These provide valuable additional insight in the material discussed by forcing you to think about the stuff you read. To make this book suitable for self-study, all exercises, except the "programming assignments", have answers in an appendix, so you can check your answers.

What's Good? Well, practically all of it. Most importantly, the clarity and depth of the text. The diagrams are excellent and do not have unnecessary graphical frills that make them hard to understand. The exercises with answers help you to get a deeper understanding of the material presented, by letting you think about it. Some exercises are easy, but some of them are non-trivial and require creativity to solve. All the code examples are working programs, not just snippets that you have to cast into something working.

Besides being an excellent textbook on Unix programming, it is also a very good reference manual. APUE is logically structured, and all the system calls are easily found, by means of boxes around them. An appendix contains an alphabetically sorted list of all the system calls discussed, with the possible return values and constants associated with them.

What's bad? Not much. There are some things that you could complain about, but I think these have mainly to do with the age of the book (it's 6 years old now), rather than lack of quality. The most important thing is that the references to the standards are a little outdated. POSIX is more mature now, and the XPG3 standard is replaced by XPG4. I do not have access to these standards, but I don't think that there are any revolutionary changes. Also, APUE talks about BSD 4.3, while 4.4 is available for quite some time now. Linux is not mentioned at all, but that is no surprise. All the material, however, is perfectly valid for Linux programming (and Stevens' newer books do refer to our favorite operating system).

Other things you can complain about are 1) it does not have any networking stuff in it, and 2) that threads (which are becoming more and more popular tool) are not discussed. For networking, I think that networking simply falls outside the scope of this book. Unix is used mainly in networked environments (and is the superior system in that environment), but it is really an extension of the capabilities of Unix, rather than a low-level integral part.

For the threads case, you have to know that this book is already 6 years old (and is still very useful, because the basic structure of Unix does not really change), and thread programming was not such a big issue in 1992, before the world jumped on Java and the Win32 API, which both are very dependent on threads.

These "deficiencies" are addressed by 2 other books of Stevens, in the form of the new edition of 'UNIX Network Programming'. In the first volume of this three-volume series the complete Unix network programming interface (both Sockets and the XTI) is explained, and contains sections on threads used in network programming. The second volume (to be published later this month) effectively expands the Interprocess Communications chapter of APUE and uses a lot of examples using the POSIX pthread interface (according to the information available about this volume). Of course, these books refer to the current standards, and even to those still in draft (but not likely to change much).

All in all, these are not very pressing reasons to not check out this book. Practically all the material is still valid, and maybe the differences between the systems where APUE talks about are gone today.

You can buy this book at Amazon.

Table of Contents Chapter 1. Introduction
Introduction * Logging In * Files and Directories * Input and Output * Programs and Processes * ANSI C Features * Error Handling * User Identification * Signals * Unix Time Values * System Calls and Library Functions * Summary

Chapter 2. Unix Standardization and Implementations
Introduction * Unix Standardization * ANSI C * IEEE POSIX * X/Open XPG3 * FIPS * Unix Implementations * System V Release 4 * 4.3+BSD * Relationship of Standards and Implementations * Limits * ANSI C Limits POSIX Limits * XPG3 Limits * sysconf, pathconf, and fpathconf Functions * FIPS 151-1 Requirements * Summary of Limits * Indeterminate Run-Time Limits * Feature Test Macros * Primitive System Data Types * Conflicts Between Standards * Summary

Chapter 3. File I/O
Introduction * File Descriptors * open Function * creat Function * close Function * lseek Function * read Function * write Function * I/O Efficiency * File Sharing * Atomic Operations * dup and dup2 Functions * fcntl Function * ioctl Function */dev/fd * Summary

Chapter 4. Files and Directories
Introduction * stat, fstat, and lstat Functions * File Types * Set-User-ID and Set-Group-ID * File Access Permissions * Ownership of New Files and Directories * access Function * umask Function * chmod and fchmod Functions * Sticky Bit * chown, fchown, and lchown Functions * File Size * File Truncation * Filesystems * link, unlink, remove, and rename Functions * Symbolic Links * symlink and readlink Functions * File Times * utime Function * mkdir and rmdir Functions * Reading Directories * chdir, fchdir, and getcwd Functions * Special Device Files * sync and fsync Functions * Summary of File Access Permission Bits * Summary

Chapter 5. Standard I/O Library
Introduction * Streams and FILE Objects * Standard Input, Standard Output, and Standard Error * Buffering * Opening a Stream * Reading and Writing a Stream * Line-at-a-Time I/O * Standard I/O Efficiency * Binary I/O * Positioning a Stream * Formatted I/O * Implementation Details * Temporary Files * Alternatives to Standard I/O * Summary

Chapter 6. System Data Files and Information
Introduction * Password File * Shadow Passwords * Group File * Supplementary Group IDs * Other Data Files * Login Accounting * System Identification * Time and Date Routines * Summary

Chapter 7. The Environment of a Unix Process
Introduction * main Function * Process Termination * Command-Line Arguments * Environment List * Memory Layout of a C Program * Shared Libraries * Memory Allocation * Environment Variables * setjmp and longjmp Functions * getrlimit and setrlimit Functions * Summary

Chapter 8. Process Control
Introduction * Process Identifiers * fork Function * vfork Function * exit Functions * wait and waitpid Functions * wait3 and wait4 Functions * Race Conditions * exec Functions * Changing User IDs and Group IDs * Interpreter Files * system Function * Process Accounting * User Identification * Process Times * Summary

Chapter 9. Process Relationships
Introduction * Terminal Logins * Network Logins * Process Groups * Sessions * Controlling Terminal * tcgetpgrp and tcsetpgrp Functions * Job Control * Shell Execution of Programs * Orphaned Process Groups * 4.3+BSD Implementation * Summary

Chapter 10. Signals
Introduction * Signal Concepts * signal Function * Unreliable Signals * Interrupted System Calls * Reentrant Functions * SIGCLD Semantics * Reliable Signal Terminology and Semantics * kill and raise Functions * alarm and pause Functions * Signal Sets * sigprocmask Function * sigpending Function * sigaction Function * sigsetjmp and siglongjmp Functions * sigsuspend Function * abort Function * system Function * sleep Function * Job-Control Signals * Additional Features * Summary

Chapter 11. Terminal I/O
Introduction * Overview * Special Input Characters * Getting and Setting Terminal Attributes * Terminal Option Flags * stty Command * Baud Rate Functions * Line Control Functions * Terminal Identification * Canonical Mode * Noncanonical Mode * Terminal Window Size * termcap, terminfo, and curses * Summary

Chapter 12. Advanced I/O
Introduction * Nonblocking I/O * Record Locking * Streams * I/O Multiplexing * select Function * poll Function * Asynchronous I/O * System V Release 4 * 4.3+BSD * readv and writev Functions * readn and writen Functions * Memory Mapped I/O * Summary

Chapter 13. Daemon Processes
Introduction * Daemon Characteristics * Coding Rules * Error Logging * SVR4 Streams log Driver * 4.3+BSD syslog Facility * Client-Server Model * Summary

Chapter 14. Interprocess Communication
Introduction * Pipes * popen and pclose Functions * Coprocesses * FIFOs * System V IPC * Identifiers and Keys Permission Structure * Configuration Limits * Advantages and Disadvantages * Message Queues * Semaphores * Shared Memory * Client-Server Properties * Summary

Chapter 15. Advanced Interprocess Communication
Introduction * Stream Pipes * Passing File Descriptors * System V Release 4 * 4.3BSD * 4.3+BSD * An Open Server, Version 1 * Client-Server Connection Functions * System V Release 4 * 4.3+BSD * An Open Server, Version 2 * Summary

Chapter 16. A Database Library
Introduction * History * The Library * Implementation Overview * Centralized or Decentralized? * Concurrency * Source Code * Performance * Summary

Chapter 17. Communicating with a PostScript Printer
Introduction * PostScript Communication Dynamics * Printer Spooling * Source Code Summary

Chapter 18. A Modem Dialer
Introduction * History * Program Design * Data Files * Server Design * Server Source Code * Client Design * Client Source Code * Summary

Chapter 19. Pseudo Terminals
Introduction * Overview * Opening Pseudo-Terminal Devices * System V Release 4 * 4.3+BSD * pty_fork Function * pty Program * Using the pty Program * Advanced Features * Summary

Appendix A. Function Prototypes

Appendix B. Miscellaneous Source Code
Our Header File * Standard Error Routines

Appendix C. Solutions to Selected Exercises

Bibliography

Index

Links to Web pages related to APUE

• W. Richard Stevens' home page
• Addison-Wesley's page on APUE

You can buy this book at Amazon.

Arjen Laarhoven has graciously provided the Slashdot community with a review of Advanced Programming in the Unix Environment. Basically, if your goal is guru-dom, then this book is for you, covering the a full range of systems programming. Check out the review below. Advanced Programming in the UNIX® Environment author W. Richard Stevens pages publisher Addison Wesley Publishing Company, Inc. rating 10/10 reviewer Arjen Laarhoven ISBN 0-201-56317-7 summary

If you want to learn how to make (systems) programs in Unix, this book is invaluable. Whether you are an experienced professional programmer coming from another environment such as Windows or Mac, or a college student who wants to make programs that run on Linux, *BSD and/or workstations at school, this book is for you, and is an excellent step in the direction of Unix guru-hood.

Today, things like graphics, object-oriented programming, Java, Perl and component-ware are highly valued, and sometimes with good reason. But more and more an important aspect of programming is neglected: systems programming. Getting as close to the underlying system as possible. I think that it is important for anyone interested in programming on a particular platform (and not only the Unix platform) to get at least a "nodding acquaintance" with the API of that underlying system. It gives you a valuable insight in how things are done, and enables you to make more intelligent design and implementation decisions in programming on a higher level. Also, it is real fun (IMHO) to really get down to the system (but this is not news to Linux hackers :-).

Advanced Programming in the UNIX® Environment (APUE) is a book that shows how to get close to the Unix system, while remaining portable across the different flavors of Unix. It does this with remarkable clarity. Anyone who knows books written by Stevens knows what I'm talking about. All his books are of very high quality. I own them all, except the first edition of UNIX Network Programming.

APUE is somewhat structured like a textbook on operating systems, unsurprisingly. It begins with an overview introduction of Unix, explaining some important basic concepts, and the standardization of Unix. See the table of contents at the end of this review.

There are three chapters with complete example applications, in which practically all the material in the preceding chapters is used in a real-world setting. These examples are completely worked out, explaining how and why certain things are done as they are.

The most striking thing about this book that it really explains the system calls and their relationships with other parts of the system, rather than just summing up system calls and leaving you in the dark about how, why and where to use them. Also, there are a lot of tables, diagrams and shell interaction transcripts that summarize and visualize the workings of the system calls and the programs that use them.

Although you can learn much by just reading, you really gain an understanding by really working with the material presented. A lot of complete code examples are given throughout the book, and Stevens invites, no urges you to compile, run and tinker with it. All the examples are available in a package which can be downloaded from Stevens' home page, ready to compile, run and modify.

What's in it for me? You can learn how to program in Unix by studying the manual pages and reading other people's code (which you should :-), but this book makes the learning curve much more smooth by providing an overview of the concepts and the relationships between them, before diving deep into the details.

An important aspect of Unix programming is portability. APUE contains many pointers on writing programs that are portable across different Unix systems, taking the SysV and BSD differences as a starting point. Also, APUE discusses standards as POSIX.1, XPG3 (now XPG4) and explains the differences between them where appropriate. The code examples are in ANSI (ISO) C. An important part of C is the Standard I/O Library, and APUE provides a whole chapter on this, comparing the Standard I/O Library with the low-level file I/O systems calls, and the relationship between them.

The most important feature of this book (IMHO) are the exercises at the end of each chapter. These provide valuable additional insight in the material discussed by forcing you to think about the stuff you read. To make this book suitable for self-study, all exercises, except the "programming assignments", have answers in an appendix, so you can check your answers.

What's Good? Well, practically all of it. Most importantly, the clarity and depth of the text. The diagrams are excellent and do not have unnecessary graphical frills that make them hard to understand. The exercises with answers help you to get a deeper understanding of the material presented, by letting you think about it. Some exercises are easy, but some of them are non-trivial and require creativity to solve. All the code examples are working programs, not just snippets that you have to cast into something working.

Besides being an excellent textbook on Unix programming, it is also a very good reference manual. APUE is logically structured, and all the system calls are easily found, by means of boxes around them. An appendix contains an alphabetically sorted list of all the system calls discussed, with the possible return values and constants associated with them.

What's bad? Not much. There are some things that you could complain about, but I think these have mainly to do with the age of the book (it's 6 years old now), rather than lack of quality. The most important thing is that the references to the standards are a little outdated. POSIX is more mature now, and the XPG3 standard is replaced by XPG4. I do not have access to these standards, but I don't think that there are any revolutionary changes. Also, APUE talks about BSD 4.3, while 4.4 is available for quite some time now. Linux is not mentioned at all, but that is no surprise. All the material, however, is perfectly valid for Linux programming (and Stevens' newer books do refer to our favorite operating system).

Other things you can complain about are 1) it does not have any networking stuff in it, and 2) that threads (which are becoming more and more popular tool) are not discussed. For networking, I think that networking simply falls outside the scope of this book. Unix is used mainly in networked environments (and is the superior system in that environment), but it is really an extension of the capabilities of Unix, rather than a low-level integral part.

For the threads case, you have to know that this book is already 6 years old (and is still very useful, because the basic structure of Unix does not really change), and thread programming was not such a big issue in 1992, before the world jumped on Java and the Win32 API, which both are very dependent on threads.

These "deficiencies" are addressed by 2 other books of Stevens, in the form of the new edition of 'UNIX Network Programming'. In the first volume of this three-volume series the complete Unix network programming interface (both Sockets and the XTI) is explained, and contains sections on threads used in network programming. The second volume (to be published later this month) effectively expands the Interprocess Communications chapter of APUE and uses a lot of examples using the POSIX pthread interface (according to the information available about this volume). Of course, these books refer to the current standards, and even to those still in draft (but not likely to change much).

All in all, these are not very pressing reasons to not check out this book. Practically all the material is still valid, and maybe the differences between the systems where APUE talks about are gone today.

You can buy this book at Amazon.

Table of Contents Chapter 1. Introduction
Introduction * Logging In * Files and Directories * Input and Output * Programs and Processes * ANSI C Features * Error Handling * User Identification * Signals * Unix Time Values * System Calls and Library Functions * Summary

Chapter 2. Unix Standardization and Implementations
Introduction * Unix Standardization * ANSI C * IEEE POSIX * X/Open XPG3 * FIPS * Unix Implementations * System V Release 4 * 4.3+BSD * Relationship of Standards and Implementations * Limits * ANSI C Limits POSIX Limits * XPG3 Limits * sysconf, pathconf, and fpathconf Functions * FIPS 151-1 Requirements * Summary of Limits * Indeterminate Run-Time Limits * Feature Test Macros * Primitive System Data Types * Conflicts Between Standards * Summary

Chapter 3. File I/O
Introduction * File Descriptors * open Function * creat Function * close Function * lseek Function * read Function * write Function * I/O Efficiency * File Sharing * Atomic Operations * dup and dup2 Functions * fcntl Function * ioctl Function */dev/fd * Summary

Chapter 4. Files and Directories
Introduction * stat, fstat, and lstat Functions * File Types * Set-User-ID and Set-Group-ID * File Access Permissions * Ownership of New Files and Directories * access Function * umask Function * chmod and fchmod Functions * Sticky Bit * chown, fchown, and lchown Functions * File Size * File Truncation * Filesystems * link, unlink, remove, and rename Functions * Symbolic Links * symlink and readlink Functions * File Times * utime Function * mkdir and rmdir Functions * Reading Directories * chdir, fchdir, and getcwd Functions * Special Device Files * sync and fsync Functions * Summary of File Access Permission Bits * Summary

Chapter 5. Standard I/O Library
Introduction * Streams and FILE Objects * Standard Input, Standard Output, and Standard Error * Buffering * Opening a Stream * Reading and Writing a Stream * Line-at-a-Time I/O * Standard I/O Efficiency * Binary I/O * Positioning a Stream * Formatted I/O * Implementation Details * Temporary Files * Alternatives to Standard I/O * Summary

Chapter 6. System Data Files and Information
Introduction * Password File * Shadow Passwords * Group File * Supplementary Group IDs * Other Data Files * Login Accounting * System Identification * Time and Date Routines * Summary

Chapter 7. The Environment of a Unix Process
Introduction * main Function * Process Termination * Command-Line Arguments * Environment List * Memory Layout of a C Program * Shared Libraries * Memory Allocation * Environment Variables * setjmp and longjmp Functions * getrlimit and setrlimit Functions * Summary

Chapter 8. Process Control
Introduction * Process Identifiers * fork Function * vfork Function * exit Functions * wait and waitpid Functions * wait3 and wait4 Functions * Race Conditions * exec Functions * Changing User IDs and Group IDs * Interpreter Files * system Function * Process Accounting * User Identification * Process Times * Summary

Chapter 9. Process Relationships
Introduction * Terminal Logins * Network Logins * Process Groups * Sessions * Controlling Terminal * tcgetpgrp and tcsetpgrp Functions * Job Control * Shell Execution of Programs * Orphaned Process Groups * 4.3+BSD Implementation * Summary

Chapter 10. Signals
Introduction * Signal Concepts * signal Function * Unreliable Signals * Interrupted System Calls * Reentrant Functions * SIGCLD Semantics * Reliable Signal Terminology and Semantics * kill and raise Functions * alarm and pause Functions * Signal Sets * sigprocmask Function * sigpending Function * sigaction Function * sigsetjmp and siglongjmp Functions * sigsuspend Function * abort Function * system Function * sleep Function * Job-Control Signals * Additional Features * Summary

Chapter 11. Terminal I/O
Introduction * Overview * Special Input Characters * Getting and Setting Terminal Attributes * Terminal Option Flags * stty Command * Baud Rate Functions * Line Control Functions * Terminal Identification * Canonical Mode * Noncanonical Mode * Terminal Window Size * termcap, terminfo, and curses * Summary

Chapter 12. Advanced I/O
Introduction * Nonblocking I/O * Record Locking * Streams * I/O Multiplexing * select Function * poll Function * Asynchronous I/O * System V Release 4 * 4.3+BSD * readv and writev Functions * readn and writen Functions * Memory Mapped I/O * Summary

Chapter 13. Daemon Processes
Introduction * Daemon Characteristics * Coding Rules * Error Logging * SVR4 Streams log Driver * 4.3+BSD syslog Facility * Client-Server Model * Summary

Chapter 14. Interprocess Communication
Introduction * Pipes * popen and pclose Functions * Coprocesses * FIFOs * System V IPC * Identifiers and Keys Permission Structure * Configuration Limits * Advantages and Disadvantages * Message Queues * Semaphores * Shared Memory * Client-Server Properties * Summary

Chapter 15. Advanced Interprocess Communication
Introduction * Stream Pipes * Passing File Descriptors * System V Release 4 * 4.3BSD * 4.3+BSD * An Open Server, Version 1 * Client-Server Connection Functions * System V Release 4 * 4.3+BSD * An Open Server, Version 2 * Summary

Chapter 16. A Database Library
Introduction * History * The Library * Implementation Overview * Centralized or Decentralized? * Concurrency * Source Code * Performance * Summary

Chapter 17. Communicating with a PostScript Printer
Introduction * PostScript Communication Dynamics * Printer Spooling * Source Code Summary

Chapter 18. A Modem Dialer
Introduction * History * Program Design * Data Files * Server Design * Server Source Code * Client Design * Client Source Code * Summary

Chapter 19. Pseudo Terminals
Introduction * Overview * Opening Pseudo-Terminal Devices * System V Release 4 * 4.3+BSD * pty_fork Function * pty Program * Using the pty Program * Advanced Features * Summary

Appendix A. Function Prototypes

Appendix B. Miscellaneous Source Code
Our Header File * Standard Error Routines

Appendix C. Solutions to Selected Exercises

Bibliography

Index

Links to Web pages related to APUE

• W. Richard Stevens' home page
• Addison-Wesley's page on APUE

You can buy this book at Amazon.

The Joker wrote in with a strange question. He has a cable modem with a 750 meg/month limit, along with an ISDN line. He asks "Is it possible to do ip accounting in such a way that he will start using my isdn connection as soon as the monthly traffic reaches 650 mb, but will keep the other line open."