This book describes application development using the Microsoft Windows Windows Application Programming Interface (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 book's scope. The examples concentrate on realistic scenarios, and in many cases the examples can be used as the foundations for real applications.

The Win32/Win64 API, or the "Windows API", is supported by Microsoft's family of 32-bit and 64-bit operating systems, which currently consists of Windows XP, Windows 2000, and Windows 2003. Older Windows family members include Windows NT, Me, 98, and 95; these systems are considered to be obsolete, but they will run many of the example programs. Migration issues from Win32 to the emerging Win64 are discussed as required. Win64, supported as a 64-bit interface on some versions of Windows 2003 and XP, is nearly identical to Win32.

There is no doubt that the Windows API is an important factor for application development, in many cases replacing the POSIX API, supported by UNIX and Linux, as the preferred, or, at least, peer, API for applications targeted at desktop and server systems. Therefore, many experienced programmers will want to learn the Windows API quickly, and this book is designed to help them do so.

The first objectives are to explain what Windows 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, neithercomprehensive nor a reference guide, but it explains the central features of the most important functions and shows how to use them in practical 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 Windows API easy to learn using this approach, and I have greatly enjoyed developing Windows programs, despite occasional frustration. This enthusiasm will show through at times, as it should. This does not mean that I feel that Windows is necessarily better than other operating system APIs, but it certainly has many attractive features.

Many Windows 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, Linux, IBM MVS, OpenVMS, or another operating system will be familiar with these concepts and will be impatient to find out how they are implemented in Windows. Most Windows 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.

The book takes the point of view that Windows is just an operating system (OS) API, providing a well understood set of features. Many programmers, regardless of experience level, need to learn Windows and the Windows operating systems quickly, and an understanding of Windows 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.

Audience

• Anyone who wants to learn about Windows application development quickly, regardless of previous experience.
• Programmers and software engineers who must port existing applications, often in UNIX, to Windows for operation on any of the Windows platforms. The book contains many comparisons among Windows, UNIX, and standard C library functions and programming models. All common UNIX functionality, including process management, synchronization, file systems, and interprocess communication, is covered in Windows terms.
• Readers starting new projects who are not constrained by the need to port existing code. Many aspects of program design and implementation are covered, and Windows functions are used to create useful applications and to solve common programming problems.
• Programmers using COM and .NET will find much of the information here helpful in understanding DLLs, thread usage and models, interfaces, and synchronization.
• Computer science students at the upperclass undergraduate or beginning graduate level in courses covering systems programming or application development. This book will also be useful to those who are learning multithreaded programming or need to build networked applications. This book would be a useful complementary text to a book such as W. Richard Stevens' Advanced Programming in the UNIX Environment (see the Bibliography) so that students could compare Windows and UNIX. Students in operating systems courses will find this book to be a useful supplement as it illustrates how a commercially important operating system provides essential OS functionality.

The only other assumption, implicit in all the others, is a knowledge of C programming.

Changes in the Third Edition

• The Third Edition includes extensive new material along with significant updating and reorganization of the first and second editions. Objectives of the Third Edition include:
• Cover important new features of Windows XP, 2000, and 2003 along with Win64 migration.
• Obsolete Windows 95, 98, and Me (the "Windows 9x" family), since Windows XP is now provided with personal systems and Windows 9x limitations are no longer relevant. Program examples freely exploit features only found in current Windows versions, even though some programs will not operate on Windows 9x.
• Provide enhanced coverage of threads and synchronization including performance, scalability, and reliability considerations. Chapter 9 is new, as are some examples in Chapter 10.
• Emphasize the increasingly important role, and new features, of Windows 2000 and 2003 in running high performance, scalable, multithreaded server applications.
• Study performance implications of different program designs, especially in multithreaded programs with synchronization and when running on SMP systems.
• Incorporate reader and student feedback to fix defects, improve explanations, improve the organization, and address numerous details, large and small.
< 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 memory management, and file mapping, and then to processes, threads, and synchronization, followed by interprocess and network communication and security. 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 and security, appear last.

Within each chapter, after introducing the functionality area, such as process management or memory-mapped files, we discuss important Windows 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 book's web site (URL TDB). Throughout, we identify those features supported only by current Windows versions (XP, 2000, and 2003) but not by earlier versions such as Windows 9x and NT, which 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 Windows. A simple example program shows the basic elements of Windows programming style and lays the foundation for more advanced Windows 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, is also introduced in Chapter 2. Examples include sequential and direct file processing, directory traversal, and file archiving. Chapter 3 ends with a discussion of registry management programming, which is similar in many ways to file and directory management.

Chapter 4 introduces Windows' exception handling, including Structured Exception Handling (SEH), 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. Vectored exception handling, a newer feature, is also described.

Chapter 5 treats Windows 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 6 introduces Windows processes, process management, and simple process synchronization. Chapter 7 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 8, 9, and 10 provide an extended, in-depth treatment of Windows thread synchronization, one of Windows' strong features. Synchronization is a complex topic, and these chapters use extended ex understood models to help you obtain the programming and performance benefits of threads while avoiding many of the pitfalls. There is new material covering performance and scalability issues, which are important when building server-based applications, including those that will run on symmetric multiprocessor (SMP) systems.

Chapters 11 and 12 are concerned with interprocess and interthread communication and networking. Chapter 11 concentrates on the features that are properly part of Windows--namely, anonymous 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 the Windows API, 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 allows server applications, such as the ones created in Chapters 11 and 12, to be converted to "Windows Services" that can be managed as background servers. Some small programming changes will turn the servers into services.

Chapter 14 shows how to perform asynchronous I/O using overlapped I/O with events and completion routines. You can achieve much the same thing with threads, so examples compare the different solutions for simplicity and performance. The closely related I/O completion ports are, however, necessary for scalable multithreaded servers, so this feature is illustrated with the servers created in earlier chapters. Finally, waitable timers are describe because they require concepts introduced earlier in the chapter.

Chapter 15 explains Windows object security, showing, in an example, how to emulate UNIX-style file permissions. Additional examples shows how to secure processes, threads, and named pipers. Security upgrades can then be applied to the earlier examples as appropriate.

Chapter 16 concludes with a description of Win64 programming issues and how to assure that code is portable to Win64. An earlier example is then ported to Win64.

There are three appendices. Appendix A describes the programs on the website and how to use them. Appendix B contains several tables that compare Windows 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 Windows features, both basic and advanced, and the C library.

UNIX and C Library Notes and Tables

Within the text at appropriate points, we contrast Windows 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.

Examples

The examples are designed to do the following:

• Illustrate common, representative, and useful applications of the Windows functions.
• Correspond to real programming situa program development, consulting, and teaching. Some of my clients and course participants have used the code examples as the bases for their own systems. During my consulting activities, I frequently encounter code that is similar to that used in the examples, and on several occasions I have seen code taken directly from the First or Second Edition. (Feel free to do so yourself, and an acknowledgment in your documentation would be greatly appreciated.) Frequently, this code occurs as part of COM or C++ objects. The examples, subject to time and space constraints, are "real-world" examples and solve "real-world" problems.
• Emphasize how the functions actually behave and interact, which is not always as you might first expect after reading the documentation. Throughout this book, the text and the examples concentrate on interactions between functions rather than the functions themselves.
• Grow and expand, adding new capability to a previous solution in an easy and natural manner and exploring alternative implementation techniques.
• In the earlier chapters, many examples implement UNIX commands, such as ls, touch, chmod, and sort, showing the Windows functions in a familiar context while creating a useful set of utilities. Different implementations of the same command will also give us an easy way to compare performance benefits available with advanced Windows features. Appendix C contains the results of these performance tests.

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, an functionality that is important but beyond the book's scope. 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 XP, 2000, and 2003. Where appropriate, they have been tested under Windows 9x and NT. Although the bulk of the development was performed on single-processor, Intel-based systems, most 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*—nd, better still, fixes.