“If you’re writing a native Win32 program or just want to know what the OS is really doing underneath, you need John’s book. He covers the stuff that real systems programmers absolutely must know. Recommended.”
–Chris Sells, Microsoft Corporation
“This fourth edition does a great job of incorporating new features in the Vista, Windows 2008, and Windows 7 API, but also stays true to teaching the foundational elements of building applications that target the Windows OS.”
–Jason Beres, Product Management, Infragistics
The Definitive Guide to Windows API Programming, Fully Updated for Windows 7, Windows Server 2008, and Windows Vista
Windows System Programming, Fourth Edition, now contains extensive new coverage of 64-bit programming, parallelism, multicore systems, and many other crucial topics. Johnson Hart’s robust code examples have been updated and streamlined throughout. They have been debugged and tested in both 32-bit and 64-bit versions, on single and multiprocessor systems, and under Windows 7, Vista, Server 2008, and Windows XP. To clarify program operation, sample programs are now illustrated with dozens of screenshots.
Hart systematically covers Windows externals at the API level, presenting practical coverage of all the services Windows programmers need, and emphasizing how Windows functions actually behave and interact in real-world applications. Hart begins with features used in single-process applications and gradually progresses to more sophisticated functions and multithreaded environments. Topics covered include file systems, memory management, exceptions, processes, threads, synchronization, interprocess communication, Windows services, and security.
New coverage in this edition includes
- Leveraging parallelism and maximizing performance in multicore systems
- Promoting source code portability and application interoperability across Windows, Linux, and UNIX
- Using 64-bit address spaces and ensuring 64-bit/32-bit portability
- Improving performance and scalability using threads, thread pools, and completion ports
- Techniques to improve program reliability and performance in all systems
- Windows performance-enhancing API features available starting with Windows Vista, such as slim reader/writer locks and condition variables
A companion Web site, jmhartsoftware.com, contains all sample code, Visual Studio projects, additional examples, errata, reader comments, and Windows commentary and discussion.
Table of Contents:
Figures xvii
Tables xix
Programs xxi
Program Runs xxv
Preface xxvii
About the Author xxxvii
Chapter 1: Getting Started with Windows 1
Operating System Essentials 1
Windows Evolution 2
Windows Versions 3
The Windows Market Role 5
Windows, Standards, and Open Systems 6
Windows Principles 7
32-bit and 64-bit Source Code Portability 10
The Standard C Library: When to Use It for File Processing 10
What You Need to Use This Book 11
Example: A Simple Sequential File Copy 13
Summary 20
Exercises 22
Chapter 2: Using the Windows File System and Character I/O 25
The Windows File Systems 26
File Naming 27
Opening, Reading, Writing, and Closing Files 28
Interlude: Unicode and Generic Characters 34
Unicode Strategies 37
Example: Error Processing 38
Standard Devices 39
Example: Copying Multiple Files to Standard Output 41
Example: Simple File Encryption 43
File and Directory Management 46
Console I/O 51
Example: Printing and Prompting 53
Example: Printing the Current Directory 55
Summary 56
Exercises 57
Chapter 3: Advanced File and Directory Processing, and the Registry 59
The 64-Bit File System 59
File Pointers 60
Getting the File Size 64
Example: Random Record Updates 65
File Attributes and Directory Processing 70
Example: Listing File Attributes 75
Example: Setting File Times 78
File Processing Strategies 80
File Locking 81
The Registry 86
Registry Management 88
Example: Listing Registry Keys and Contents 92
Summary 96
Exercises 97
Chapter 4: Exception Handling 101
Exceptions and Their Handlers 101
Floating-Point Exceptions 108
Errors and Exceptions 110
Example: Treating Errors as Exceptions 112
Termination Handlers 113
Example: Using Termination Handlers to Improve Program Quality 117
Example: Using a Filter Function 120
Console Control Handlers 124
Example: A Console Control Handler 126
Vectored Exception Handling 128
Summary 129
Exercises 130
Chapter 5: Memory Management, Memory-Mapped Files, and DLLs 131
Windows Memory Management Architecture 132
Heaps 134
Managing Heap Memory 137
Example: Sorting Files with a Binary Search Tree 143
Memory-Mapped Files 149
Example: Sequential File Processing with Mapped Files 156
Example: Sorting a Memory-Mapped File 158
Example: Using Based Pointers 162
Dynamic Link Libraries 167
Example: Explicitly Linking a File Conversion Function 172
The DLL Entry Point 174
DLL Version Management 175
Summary 177
Exercises 178
Chapter 6: Process Management 181
Windows Processes and Threads 181
Process Creation 183
Process Identities 190
Duplicating Handles 191
Exiting and Terminating a Process 192
Waiting for a Process to Terminate 194
Environment Blocks and Strings 195
Example: Parallel Pattern Searching 197
Processes in a Multiprocessor Environment 201
Process Execution Times 202
Example: Process Execution Times 202
Generating Console Control Events 204
Example: Simple Job Management 205
Example: Using Job Objects 215
Summary 219
Exercises 220
Chapter 7: Threads and Scheduling 223
Thread Overview 223
Thread Basics 225
Thread Management 226
Using the C Library in Threads 231
Example: Multithreaded Pattern Searching 232
Performance Impact 235
The Boss/Worker and Other Threading Models 236
Example: Merge-Sort–Exploiting Multiple Processors 237
Introduction to Program Parallelism 244
Thread Local Storage 245
Process and Thread Priority and Scheduling 246
Thread States 249
Pitfalls and Common Mistakes 251
Timed Waits 252
Fibers 253
Summary 256
Exercises 256
Chapter 8: Thread Synchronization 259
The Need for Thread Synchronization 259
Thread Synchronization Objects 268
CRITICAL_SECTION Objects 269
A CRITICAL_SECTION for Protecting Shared Variables 271
Example: A Simple Producer/Consumer System 273
Mutexes 279
Semaphores 284
Events 287
Example: A Producer/Consumer System 289
More Mutex and CRITICAL_SECTION Guidelines 294
More Interlocked Functions 296
Memory Management Performance Considerations 297
Summary 298
Exercises 298
Chapter 9: Locking, Performance, and NT6 Enhancements 301
Synchronization Performance Impact 302
A Model Program for Performance Experimentation 307
Tuning Multiprocessor Performance with CS Spin Counts 307
NT6 Slim Reader/Writer Locks 309
Thread Pools to Reduce Thread Contention 312
I/O Completion Ports 316
NT6 Thread Pools 316
Summary: Locking Performance 324
Parallelism Revisited 325
Processor Affinity 329
Performance Guidelines and Pitfalls 331
Summary 332
Exercises 333
Chapter 10: Advanced Thread Synchronization 335
The Condition Variable Model and Safety Properties 336
Using SignalObjectAndWait 342
Example: A Threshold Barrier Object 344
A Queue Object 348
Example: Using Queues in a Multistage Pipeline 352
Windows NT6 Condition Variables 362
Asynchronous Procedure Calls 366
Queuing Asynchronous Procedure Calls 367
Alertable Wait States 368
Safe Thread Cancellation 371
Pthreads for Application Portability 372
Thread Stacks and the Number of Threads 372
Hints for Designing, Debugging, and Testing 372
Beyond the Windows API 375
Summary 375
Exercises 376
Chapter 11: Interprocess Communication 379
Anonymous Pipes 380
Example: I/O Redirection Using an Anonymous Pipe 380
Named Pipes 384
Named Pipe Transaction Functions 390
Example: A Client/Server Command Line Processor 393
Comments on the Client/Server Command Line Processor 399
Mailslots 401
Pipe and Mailslot Creation, Connection, and Naming 405
Example: A Server That Clients Can Locate 406
Summary 408
Exercises 408
Chapter 12: Network Programming with Windows Sockets 411
Windows Sockets 412
Socket Server Functions 414
Socket Client Functions 419
Comparing Named Pipes and Sockets 421
Example: A Socket Message Receive Function 422
Example: A Socket-Based Client 423
Example: A Socket-Based Server with New Features 426
In-Process Servers 434
Line-Oriented Messages, DLL Entry Points, and TLS 436
Example: A Thread-Safe DLL for Socket Messages 437
Example: An Alternative Thread-Safe DLL Strategy 442
Datagrams 445
Berkeley Sockets versus Windows Sockets 447
Overlapped I/O with Windows Sockets 447
Windows Sockets Additional Features 448
Summary 448
Exercises 449
Chapter 13: Windows Services 453
Writing Windows Services–Overview 454
The main() Function 454
ServiceMain() Functions 455
The Service Control Handler 460
Event Logging 461
Example: A Service “Wrapper” 461
Managing Windows Services 467
Summary: Service Operation and Management 471
Example: A Service Control Shell 472
Sharing Kernel Objects with a Service 476
Notes on Debugging a Service 477
Summary 478
Exercises 478
Chapter 14: Asynchronous Input/Output and Completion Ports 481
Overview of Windows Asynchronous I/O 482
Overlapped I/O 483
Example: Synchronizing on a File Handle 487
Example: File Conversion with Overlapped I/O and Multiple Buffers 487
Extended I/O with Completion Routines 492
Example: File Conversion with Extended I/O 496
Asynchronous I/O with Threads 500
Waitable Timers 501
Example: Using a Waitable Timer 503
I/O Completion Ports 505
Example: A Server Using I/O Completion Ports 509
Summary 516
Exercises 517
Chapter 15: Securing Windows Objects 519
Security Attributes 519
Security Overview: The Security Descriptor 520
Security Descriptor Control Flags 523
Security Identifiers 523
Managing ACLs 525
Example: UNIX-Style Permission for NTFS Files 527
Example: Initializing Security Attributes 531
Reading and Changing Security Descriptors 535
Example: Reading File Permissions 537
Example: Changing File Permissions 538
Securing Kernel and Communication Objects 539
Example: Securing a Process and Its Threads 541
Overview of Additional Security Features 542
Summary 544
Exercises 544
Appendix A: Using the Sample Programs 547
Examples File Organization 548
Appendix B: Source Code Portability: Windows, UNIX, and Linux 549
Source Code Portability Strategies 550
Windows Services for UNIX 550
Source Code Portability for Windows Functionality 551
Chapters 2 and 3: File and Directory Management 556
Chapter 4: Exception Handling 561
Chapter 5: Memory Management, Memory-Mapped Files, and DLLs 562
Chapter 6: Process Management 563
Chapter 7: Threads and Scheduling 565
Chapters 8—10: Thread Synchronization 567
Chapter 11: Interprocess Communication 569
Chapter 14: Asynchronous I/O 571
Chapter 15: Securing Windows Objects 572
Appendix C: Performance Results 575
Test Configurations 575
Performance Measurements 577
Running the Tests 591
Bibliography 593
Index 597
About the Author :
Johnson M. Hart is a consultant specializing in Microsoft Windows and .NET application development, open systems computing, technical training and writing, and software engineering. He has more than twenty-five years of experience as a software engineer, manager, engineering director, and senior technology consultant at Cilk Arts, Inc., Sierra Atlantic, Hewlett-Packard, and Apollo Computer. He served as computer science professor at the University of Kentucky for nine years, and has authored all four editions of Windows System Programming.
Review :
“If you’re writing a native Win32 program or just want to know what the OS is really doing underneath, you need John’s book. He covers the stuff that real systems programmers absolutely must know. Recommended.”
–Chris Sells, Microsoft Corporation
“This fourth edition does a great job of incorporating new features in the Vista, Windows 2008, and Windows 7 API, but also stays true to teaching the foundational elements of building applications that target the Windows OS.”
–Jason Beres, Product Management, Infragistics
