"If you are new to the Win32 API, but have programmed for other high-end operating systems such as UNIX or VMS, then Win32 System Programming is the book for you. HIGHLY RECOMMENDED."
--Christopher L.T. Brown, Windows 2000 Magazine
A practical guide to the central features and functions of the Win32 API, Win32 System Programming, Second Edition, will get you up and running with Windows NT and Windows 2000. Unlike most Windows programming resources, this book focuses exclusively on the core system services--file system, memory, processes, communication, and security--rather than on the more commonly featured graphical user interface functions. Especially geared for those already familiar with UNIX or other high-end operating systems, Win32 System Programming, Second Edition, helps you to build on your knowledge base to learn Win32 features quickly and easily.
This new edition has been updated and enhanced with new coverage of network programming, servers, NT services, thread performance, and synchronization. It also offers a preview of Win64, the new 64-bit API for Windows 2000. Beginning with an examination of the features required in a single-process application, the text gradually progresses to increasingly sophisticated functions relating to a multithreaded environment. You will find extensive coverage of such critical Win32 topics as:
Win32 System Programming, Second Edition, will give you a solid grounding in the core operating system functions of the Windows environment, an understanding of Win64 for Windows 2000, and the know-how you need to put them to work.
Click below for Sample Chapter related to this title:
1. Getting Started with Win32 and Win64.
Operating System Essentials.
Win32 and Windows 2000, NT, 9x, and CE.
Win32, Standards, and Open Systems.
Getting Ready for Win64.
The Standard C Library: When to Use It for File Processing.
What You Need to Use This Book.
Example: A Simple Sequential File Copy.
The Win32 File Systems.
Opening, Reading, Writing, and Closing Files.
Interlude: Unicode and Generic Characters.
Standard Devices and Console I/O.
Example: Printing and Prompting.
Example: Error Processing.
Example: Copying Multiple Files to Standard Output.
Example: ASCII to Unicode Conversion.
File and Directory Management.
Example: Printing the Current Directory.
The 64-Bit File System.
Getting the File Size.
Example: Viewing the Tail of a File.
File Attributes and Directory Processing.
Example: Listing File Attributes.
Example: Setting File Times.
File Processing Strategies.
Example: Listing Registry Keys and Contents.
Exceptions and Their Handlers.
Errors and Exceptions.
Example: Treating Errors as Exceptions.
Example: Using Termination Handlers to Improve Program Quality.
Example: Using a Filter Function.
Console Control Handlers.
Example: A Console Control Handler.
Security Overview: The Security Descriptor.
Example: UNIX-Style Permission for NTFS Files.
Example: Initializing Security Attributes.
Reading and Changing Security Descriptors.
Example: Reading File Permissions.
Example: Changing File Permissions.
Overview of Additional Security Features.
Win32 Memory Management Architecture.
Managing Heap Memory.
Example: Sorting Files with a Binary Search Tree.
Example: Sequential File Processing with Mapped Files.
Example: Sorting a Memory-Mapped File.
Example: Using Based Pointers.
Dynamic Link Libraries.
Example: Explicitly Linking a File Conversion Function.
The DLL Entry Point.
Windows Processes and Threads.
Exiting and Terminating a Process.
Waiting for a Process to Terminate.
Environment Blocks and Strings.
Example: Parallel Pattern Searching.
Process Execution Times.
Example: Process Execution Times.
Generating Console Control Events.
Example: Simple Job Management.
Using the C Library in Threads.
Example: Multithreaded Pattern Searching.
The Boss/Worker and Other Threading Models.
Example: Merge-Sort — Divide and Conquer to Exploit SMP.
Thread Local Storage.
Process and Thread Priority and Scheduling.
Pitfalls and Common Mistakes.
The Need for Thread Synchronization.
Thread Synchronization Objects.
The CRITICAL_SECTION Object.
A CRITICAL_SECTION for Protecting Shared Variables.
Example: A Simple Producer/Consumer System.
Example: A Producer/Consumer System.
Example: Synchronization Performance Impact.
More Mutex and CRITICAL_SECTION Guidelines.
More Interlocked Functions.
Memory Management Performance Considerations.
Mutexes, Events, and the Condition Variable Model.
Example: A Threshold Barrier Object.
A Queue Object.
Example: Using Queues in a Multistage Pipeline.
Hints for Designing, Debugging, and Testing.
Example: I/O Redirection Using an Anonymous Pipe.
Named Pipe Transaction Functions.
Example: A Client/Server Command Line Processor.
Comments on the Client/Server Command Line Processor.
Pipe and Mailslot Creation, Connection, and Naming.
Example: A Server That Clients Can Locate.
Comments on Thread Models.
Socket Server Functions.
Socket Client Functions.
Comparing Named Pipes and Sockets.
Example: A Socket Message Receive Function.
Example: A Socket-Based Client.
Example: A Socket-Based Server with New Features.
Line-Oriented Messages, DLL Entry Points, and TLS.
Example: A Thread-Safe DLL for Socket Messages.
Example: An Alternative Thread-Safe DLL Strategy.
Berkeley vs. Windows Sockets.
Overlapped I/O with Windows Sockets.
Windows Sockets 2.
Writing NT Services — Overview.
The Main Function.
The ServiceMain Functions.
The Service Control Handler.
Example: A Service "Wrapper".
Managing Windows NT Services.
Summary: Service Operation and Management.
Example: A Service Control Shell.
Sharing Kernel Objects with a Service.
Notes on Debugging a Service.
Overview of Win32 Asynchronous I/O.
Example: Synchronizing on a File Handle.
Example: File Conversion with Overlapped I/O and Multiple Buffers.
Extended I/O with Completion Routines.
Example: File Conversion with Extended I/O.
Asynchronous I/O with Threads.
Example: Using a Waitable Timer.
I/O Completion Ports.
Example: A Server Using I/O Completion Ports.
Remote Procedure Calls.
Basic RPC Architecture.
RPC Interface Definitions.
Example: An Interface Definition.
Example: An RPC Client.
Example: An RPC Server.
A Brief COM and DCOM Overview.
64-Bit Architecture Overview.
The Win64 Programming Model.
The Data Types.
The Three Win64 Programming Models.
Legacy Code Migration.
Include File Listings.
Additional Utility Programs.
Chapters 2 and 3: File and Directory Management.
Chapter 4: Structured Exception Handling.
Chapter 5: Securing Win32 Objects.
Chapter 6: Memory Management, Memory-Mapped Files, and DLLs.
Chapter 7: Process Management.
Chapter 8: Threads and Scheduling.
Chapters 9 and 10: Thread Synchronization.
Chapter 11: Interprocess Communication.
Chapter 14: Asynchronous I/O.
Running the Tests.
This book shows how to use the Win32 Application Programming Interface (API) and the emerging Win64 API, concentrating on the core system services, including the file system, process and thread management, interprocess communication, network programming, and synchronization. User interfaces, internals, and I/O drivers, although important and interesting topics, are beyond the scope of this book. The examples concentrate on scenarios that are likely to arise in practice, and in many cases the examples can be used as bases for real applications.
The Win32 API is supported by Microsoft's family of 32-bit operating systems: Windows 2000, Windows NT, Windows 98, Windows 95, and Windows CE. Win64, to be supported as a 64-bit interface on Windows 2000, is very similar, and migration issues are discussed as required. There is no doubt that Win32, along with Win64, is an important factor for application developers, in many cases replacing UNIX as the preferred API for application programs targeted at desktop and server systems. Many observers predict that Win32 will become the dominant programming interface, although it appears that UNIX and Win32 will continue to coexist and that each will find its own niche.
Regardless of the outcome of the operating system wars, many experienced programmers will want to learn the Win32 API quickly, and this book is designed to help them do so.
The first objectives are to explain what Win32 is, show how to use it in realistic situations, and do so as quickly as possible without burdening the reader with unnecessary detail. This book is, therefore, not comprehensive, but it explains the central features of the most important functions and shows how to use them in realistic programming situations. Equipped with this knowledge, the reader will be able to use the comprehensive Microsoft reference documentation to explore details, advanced options, and the more obscure functions as requirements or interests dictate. I have found the Win32 API easy to learn using this approach, and I have greatly enjoyed developing Win32 programs, despite occasional frustration. This enthusiasm will show through at times, as it should. This does not mean that I feel that Win32 is necessarily better than other operating system APIs, but it certainly has many attractive features.Many Win32 books assume that the user is familiar only with 16-bit Windows 3.1 programming. These books spend a great deal of time explaining how processes, virtual memory, interprocess communication, and preemptive scheduling work without showing how to use them in realistic situations. A programmer experienced in UNIX, VAX VMS, IBM MVS, or another high-end operating system--that is, nearly anything other than the long-obsolete Windows 3.1 Win16 API--will be familiar with these concepts and will be impatient to find out how they are implemented in Win32. Most Win32 books also spend a great deal of space on user interface programming. This book avoids the user interface, beyond discussing simple character-based console I/O, in the interest of concentrating on the important core features.
This book takes the point of view that Win32 is just an operating system (OS) API, providing a well understood set of features. Many programmers, regardless of experience level, need to learn Win32 and the Windows operating systems quickly, and an understanding of Win32 is invaluable in discussing subjects such as Microsoft's Component Object Model (COM). The Windows systems, when compared with other systems, have good, bad, and average features and quality. The purpose of this book is to show how to use those features efficiently and in realistic situations to develop useful, high-quality, and high-performance applications.
The only other assumption, implicit in all the others, is a knowledge of C programming.
Chapters are organized topically so that the features required in even a single-threaded application are covered first, followed by process and thread management features, and finally network programming in a multithreaded environment. This organization allows the reader to advance logically from file systems to security, memory management, and file mapping, and then to processes, threads, and synchronization, followed by interprocess and network communication. This organization also allows the examples to evolve in a natural way, much as a developer might create a simple prototype and then add additional capability. The advanced features, such as asynchronous I/O, appear last.
Within each chapter, after introducing the functionality area, such as process management or memory-mapped files, we discuss important Win32 functions and their relationships in detail. Illustrative examples follow. Within the text, only essential parts of programs are listed; complete programs and the required include files, utility functions, and the like are in an appendix or on the disc provided with the book. Throughout, we identify those features supported only by Windows 2000 and NT, because Windows 98, 95, and CE do not implement many advanced features. Each chapter suggests related additional reading and gives some exercises. Many exercises address interesting and important issues that did not fit within the normal text, and others allow the reader to explore advanced or specialized topics.
Chapter 1 is a high-level introduction to the Windows OS family and Win32. A simple example program shows the basic elements of Win32 programming style and lays the foundation for more advanced Win32 features. Win64 and migration issues are introduced in Chapter 1, described extensively in Chapter 16, and included throughout the book as required.
Chapters 2 and 3 deal with file systems, console I/O, file locking, and directory management. Unicode, the extended character set used by Windows 2000/NT, is also introduced in Chapter 2. Examples include sequential and direct file processing and a directory traversal program. Chapter 3 ends with a discussion of registry management programming, which is similar in many ways to file and directory management.
Chapter 4 introduces Win32's Structured Exception Handling (SEH) capability, which will be used extensively throughout the book. Many books defer SEH to later chapters, but by introducing it early we will be able to use SEH throughout and thus simplify some programming tasks and improve quality.
Chapter 5 explains Windows NT object security, showing, in an example, how to emulate UNIX-style file permissions. Security upgrades can then be applied to the examples as appropriate. Although security is used in the later chapters, feel free to skip this chapter if you are not interested in this topic.
Chapter 6 treats Win32 memory management and shows how to use memory-mapped files both to simplify programming and for performance. This chapter also covers dynamic link libraries (DLLs).
Chapter 7 introduces Win32 processes, process management, and simple process synchronization. Chapter 8 then describes thread management in similar terms. Examples in each chapter show the many benefits, including program simplicity and performance, of threads and processes.
Chapters 9 and 10 provide an extended, in-depth treatment of Win32 thread synchronization, one of Win32's strong features. Synchronization is a complex topic, and these two chapters use extended examples and well understood models to help you obtain the programming and performance benefits of threads while avoiding many of the pitfalls.Chapters 11 and 12 are concerned with interprocess and interthread communication and networking. Chapter 11 concentrates on the features that are properly part of Win32--namely, pipes, named pipes, and mailslots. Chapter 12 treats Windows Sockets, which allow interoperability with non-Windows systems using industry-standard protocols, primarily TCP/IP. Windows Sockets, while not strictly part of Win32, provide for network and Internet communication and interoperability, and the subject matter is consistent with the rest of the book. A multithreaded client/server system illustrates how to use interprocess communication along with threads.
Chapter 13 describes how Windows 2000 and Windows NT provide "NT services" that allow you to manage background servers, such as the ones created in Chapters 11 and 12. Some small programming changes will turn the servers into NT services.Chapter 14 shows how to use overlapped I/O with events and completion routines. For file systems, this feature applies only to Windows 2000 and NT, and you can achieve much the same thing with threads. The closely related I/O completion ports are, however, necessary for scalable multithreaded servers, so this feature is illustrated with the servers created in Chapters 11, 12, and 13. Waitable timers are described, because they require concepts first introduced in Chapter 14.
Chapter 15 concludes with a survey of two specialized topics: Remote Procedure Calls (RPCs) and Microsoft's COM object model, which integrates many of the concepts in the book. Remote procedures and COM objects frequently use the features described throughout this book. Simple examples are included, and this chapter illustrates that readers now have the necessary information to learn other Win32 topics beyond the core system services.
Chapter 16 describes the Win64 programming issues and how to plan for application migration and portability.
There are three appendices. Appendix A describes the programs on the disc and how to use them. Appendix B contains several tables that compare Win32 functions with their counterparts in UNIX and the Standard C library. Appendix C compares the performance of alternative implementations of some of the examples in the text so that you can gauge the trade-offs between Win32 features, both basic and advanced, and the C library.
Notes on the Second Edition
The Second Edition includes extensive new material along with significant updating and reorganization. Objectives of the Second Edition include:
UNIX and C Library Notes and Tables
Within the text at appropriate points, we contrast Win32 style and functionality with the comparable UNIX (and LINUX) and ANSI Standard C library features. Tables listing the comparable functions are presented in Appendix B. This information is included because many readers are familiar with UNIX and are interested in the comparisons between the two systems. Readers without a UNIX background should feel free to skip these paragraphs. Such discussions are indented, in a smaller font.
The examples are designed to do the following:
Examples in the early chapters are usually short, but the later chapters present longer examples when appropriate.
Exercises at the end of each chapter suggest alternative designs, subjects for investigation, and additional functionality that is important but beyond the scope of this book. Some exercises are easy, and a few are very challenging. Frequently, clearly labeled defective solutions are provided, because fixing the bugs is an excellent way to sharpen skills.
All examples have been debugged and tested under Windows 2000, Windows NT, and, where appropriate, Windows 98 and 95. For Windows NT testing we used Version 4.0, and although the bulk of the development was performed on single-processor, Intel-based systems, many programs were also tested on multiprocessor systems. The client/server applications have been tested using multiple clients simultaneously interacting with a server. Nonetheless, there is no guarantee or assurance of program correctness, completeness, or fitness for any purpose. Undoubtedly, even the simplest examples contain defects or will fail under some conditions; such is the fate of nearly all software. I will, however, gratefully appreciate any messages regarding program defects--and, better still, fixes.
Book errata, along with additional examples, reader contributions, additional explanations, and much more, will be maintained at my home page: http://world.std.com/~jmhart. The code will be updated as required when defects are found and fixed and as reader input is received. If you encounter any difficulties with the programs or any material in the book, check this location first, because there may already be a fix or explanation. If that does not answer your question, feel free to send e-mail to email@example.com.