Customer Reviews

Solaris Systems Programming

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

 

 

I would recommend Thomas E. Dickey's web page to anybody with open mind to decide on this issue.

http://invisible-island.net/critique/APUE-SSP.html

I would certainly not pass my English Composition classes if I would be paraphrasing that much from somebody's work without proper references.

At first sight, the book appeared to be typical/average.
However, when checking for specific details to post an
opinion of the book I noticed something strange -
paraphrasing of material from Stevens' "Advanced Programming
in the Unix Environment". Teer does not credit the material
which is borrowed. Read more details here -
http://invisible-island.net/critique/APUE-SSP.html

Despite the claim on the back cover, the book is far away from the tradition of Richard Stevens' "Advanced Programming in the UNIX Environment". In contrast to APUE, which truly enlightens the reader with all sorts of historical, portability, and background information, Teer's book is not much more than a Solaris API description.

Many of the examples in it will not work unmodified on Linux, BSD, or other platforms. It will thus not be of much help to a novice Unix programmer unless he actually wants to write Solaris-only programs - not a common scenario in the Unix/POSIX world. But a more experienced programmer can just use the Solaris manual pages to get most of the information contained in the book.

Also the book contains one of the most stupid code examples I have ever seen: an snprintf() emulation that works by calling vsprintf() first, then checking its return value to see if the buffer size was large enough, possibly exiting with an error message:

int snprintf (char *buf, size_t n, const char *fmt, ...) { [...]
len = vsprintf (buf, fmt, ap); [...]
if (len >= n)
err_quit ("snprintf: \"%s\" caused a buffer overflow", fmt);

But when such an overflow is actually exploited on the stack by an attacker, vsprintf() may not return at all, rendering the check useless. The code thus gives a false impression of security. This might be regarded even more dangerous than code that does not perform overflow checks at all, especially in the context of a book.

I have to admit that I did not look at too many examples, but I would recommend to be cautious with the book until somebody has verified that this is the only fundamental security error in its code.

The only reason this book is a good Unix systems book is because it is a nearly section by section rip of Advanced Programming in the Unix Environment by Stevens. If you have a choice between Teer's book or Stevens book you must take Stevens' book. Stevens' 2nd edition is much more comprehensive and contains important content that Teer's book lacks, such as threads.

This is an excellent book for writing in C on the Solaris UNIX platform. If you are familiar with "UNIX Network Programming" (Stevens, Fenner, and Rudoff) and "Advance Programming in the UNIX Environment" (Stevens), then you will be comfortable with this volume. All of them contain excellent documentation and good examples, as well as a nice clean format. Although catering to Solaris, much of it is applicable to other UNIX environments as well. If you use Solaris, you will want this book.

The text is clear and easy to read, making things easy to find and use, thereby making you more productive. There are 1200+ pages, but you wouldn't think so. The paper is thin, but durable (a sign of quality publishing) and fits in with other professional publications.

This book really has a ton of stuff in it. From specific 64-bit programming topics to library function documentation to secure programming. The sections on I/O are extensive and detailed -- there could be more information on network programming (the author also refers the reader to the same "UNIX Network Programming" that I mentioned, so that is a good sign). However interprocess communications is covered very well (e.g., pipes, FIFOs, message queues, semaphores, and shared memory).

The appendices have some useful information. In addition to a function summary, the section on internationalization is good and surprisingly forward-looking. The exercises make it useful as a classroom text / reference as well.

This book already can replace several books on my shelf. Just an amazing book for your reference.

I was very disappointed that a book that claims to be "in the tradition of W. Richard Stevens" adds little to no value beyond what the original APUE (and now APUE2!) has taught generations of Unix programmers for many years. I already had a beat up copy of APUE on my shelf for years and recently purchased APUE2 (the *real* second edition of APUE). Considering SSP is very, very, very similar to APUE, I don't see the value of buying another book that doesn't add a lot of value beyond what I could figure out on my own by using APUE and Solaris manuals.

If Rich Teer was sincere in his claims of admiration for Stevens, he would have properly credited him for the majority of the "borrowed" content - not doing so is not only questionable ethics for an author but truly disrespectful to a legend that is no longer here to defend himself.

If you really want to do Solaris system programming, do yourself a favour - get a copy of APUE2 (ISBN: 0201433079), read the Solaris man pages and go hang out on developers.sun.com

This book has been very helpful to me and will enhance my understanding of Unix and more specifically, Solaris.

Before this book, I held the book, "Unix Internals: A Systems Operations Handbook" by Shaw and Shaw as the bible of figuring out the innards of Unix. Rich Teer's new book, "Solaris Systems Programming," has taken that title and will now be my favorite Unix internals book.

The book is well-written, thorough and has many examples. I wish Teer would have put in more details on threads programming, but I guess you can only go so far.

I have recommended this book to almost all of my colleagues and will recommend it to anybody with any kind of programming background as a good reference for not only learning Unix systems programming, but learning Unix and how it works from a more detailed stand-point than the "Intro" books.

This is a book I was waiting for !

Despite of the title, this isn't a "Solaris Only System Programming" book. Most ideas on it are general ideas which can be applied to most Unix like operating systems.

A book with 1200 pages of useful information on all pages ! All covered subjects are with an agreeable style and very pertinent examples.

The pleasant style makes it an excellent book not only for learning system programing, but also as a reference for experienced programmers.

What's lacking on this book is only some aspects on threads programming, some other POSIX implementations of some System V components and other aspects of networking programming. But this isn't an argument to prevent people from buying this book. This is 1200 pages book and I sincerely hope that Rich Teer will write a second volume of his book covering this issues : I'm waiting for it.

System programming with reference to a specific operating system involves the proper usage of C program function calls that the operating system has available so that programmers can hook into the internals of the operating system itself and influence and utilize such things as the file system, the date and time functions, and process control. 13 years ago when I first began UNIX system programming on Sun computers, they came with reference books that had this material. Unfortunately, that is no longer the case.

Richard Stevens' book "Advanced Programming in the Unix Environment" has been a great book on generic UNIX systems programming since it was first published. However, there are so many facets of system programming that are unique to Solaris that this is an essential book. The book is logically laid out and discusses all of the hooks available to you via Solaris system programming function calls. There are plenty of code examples, detailed explanations of function parameters, and even some exercises with some solutions available. In conjunction with "Solaris Internals", just recently released in its second edition, there is a wealth of information available on how the system programmer can monitor Solaris, or perhaps add some features of their own.

The first two chapters are an introduction to operating system components in general and the history of Solaris through Solaris 9- the current version being Solaris 10. The book is then divided into system programming topics. The first of these is "fundamental topics", which basically starts with manipulating strings using the C programming language and then goes through the basic resources available to the Solaris system programmer. Next, each topic that was covered in the introductory fundamental topics section now gets its own section in the book - input/output, process control, interprocess communication, and pseudo-terminals.

I highly recommend this book to any C programmer that needs to write programs to interface to the Solaris operating system. I notice the table of contents is not shown, so I present that next:
Part 1 INTRODUCTION
Chapter 1 Introduction 3
Chapter 2 A Brief History of Solaris 45

Part 2 FUNDAMENTAL TOPICS 57
Chapter 3 Utility Functions 59
Chapter 4 Basic File I/O 123
Chapter 5 The Standard I/O Library 159
Chapter 6 Date and Time Operations 201
Chapter 7 Users and Groups 223
Chapter 8 System Information and Resource Limits 275
Chapter 9 Secure C Programming 337

Part 3 INPUT/OUTPUT 351
Chapter 10 Files and Directories 353
Chapter 11 Working with File Systems 417
Chapter 12 Terminal I/O 461
Chapter 13 Advanced I/O 507

Part 4 PROCESSES AND PROCESS CONTROL 601
Chapter 14 The Environment of a UNIX Process 603
Chapter 15 Process Control 629
Chapter 16 Process Relationships 677
Chapter 17 Signals 703
Chapter 18 Daemon Processes 805

Part 5 INTERPROCESS COMMUNICATION 827
Chapter 19 Interprocess Communication Using Pipes and FIFOs 829
Chapter 20 The System V Interprocess Communication Facility 867
Chapter 21 Advanced Interprocess Communication 927
Chapter 22 Doors 951

Part 6 PSEUDO TERMINALS 995
Chapter 23 Pseudo Terminals 997

Appendix A An Internationalization and Localization Primer 1035
Appendix B The BSD Source Compatibility Package 1047
Appendix C Function Summary 1057
Appendix D Miscellaneous Source Code 1117
Appendix E Solutions to Selected Exercises

This book is true bible of solaris knowledge and, what is importand too - written using very simply and clear language - that (unfortunately rare) property of technical book makes it very good and useful manual.