Windows核心编程（第5版·英文版）

Part I　Required Reading

　1　Error Handling　　

　Defining Your Own Error Codes　　

　 The ErrorShow Sample Application　　

　2　Working with Characters and Strings　　

　　Character Encodings　　

　　ANSI and Unicode Character and String Data Types　　

　　Unicode and ANSI Functions in Windows　　

　　Unicode and ANSI Functions in the C Run-Time Library　　

　　Secure String Functions in the C Run-Time Library　　

　　　Introducing the New Secure String Functions　　

　　　How to Get More Control When Performing String Operations　　

　　　Windows String Functions　　

　　Why You Should Use Unicode　　

　　How We Recommend Working with Characters and Strings　　

　　Translating Strings Between Unicode and ANSI　　

　　　Exporting ANSI and Unicode DLL Functions　　

　　　Determining If Text Is ANSI or Unicode　　

　3　Kernel Objects　　

　　What Is a Kernel Object?　　

　　　Usage Counting　　

　　　Security　　

　　A Process’ Kernel Object Handle Table　　

　　　Creating a Kernel Object　　

　　　Closing a Kernel Object　　

　　Sharing Kernel Objects Across Process Boundaries　　

　　　Using Object Handle Inheritance　　

　　　Naming Objects　　

　　　Duplicating Object Handles　　

Part II　Getting Work Done

　4　Processes　　

　　Writing Your First Windows Application　　

　　　A Process Instance Handle　　

　　The CreateProcess Function　　

　　　pszApplicationName and pszCommandLine　　

　　Terminating a Process　　

　　　The Primary Thread’s Entry-Point Function Returns　　

　　　The ExitProcess Function　　

　　　The TerminateProcess Function　　

　　　When All the Threads in the Process Die　　

　　　When a Process Terminates　　

　　Child Processes　　

　　　Running Detached Child Processes　　

　　When Administrator Runs as a Standard User　　

　　　Elevating a Process Automatically　　

　　　Elevating a Process by Hand　　

　　　What Is the Current Privileges Context?　　

　　　Enumerating the Processes Running in the System　　

　5　Jobs　　

　　Placing Restrictions on a Job’s Processes　　

　　Placing a Process in a Job　　

　　Terminating All Processes in a Job Querying Job Statistics　　

　　Job Notifications　　

　　The Job Lab Sample Application　　

6　Thread Basics　　

　　When to Create a Thread　　

　　When Not to Create a Thread　　

　　Writing Your First Thread Function　　

　　The CreateThread Function　　

　　　psa　　

　　　cbStackSize　　

　　　pfnStartAddr and pvParam　　

　　　dwCreateFlags　　

　　　pdwThreadID　　

　　Terminating a Thread　　

　　　The Thread Function Returns　　

　　　The ExitThread Function　　

　　　The TerminateThread Function　　

　　　When a Process Terminates　　

　　　When a Thread Terminates　　

　　Some Thread Internals　　

　　C/C++ Run-Time Library Considerations　　

　　　Oops—I Called CreateThread Instead of _beginthreadex by Mistake　　

　　　C/C++ Run-Time Library Functions That You Should Never Call　　

　　Gaining a Sense of One’s Own Identity　　

　　　Converting a Pseudohandle to a Real Handle　　

7　Thread Scheduling, Priorities, and Affinities　　

　　Suspending and Resuming a Thread　　

　　Suspending and Resuming a Process　　

　　Sleeping　　

　　Switching to Another Thread　　

　　Switching to Another Thread on a Hyper-Threaded CPU　　

　　A Thread’s Execution Times　　

　　Putting the CONTEXT in Context　　

　　Thread Priorities　　

　　An Abstract View of Priorities　　

　　Programming Priorities　　

　　　Dynamically Boosting Thread Priority Levels　　

　　　Tweaking the Scheduler for the Foreground Process　　

　　　Scheduling I/O Request Priorities　　

　　　The Scheduling Lab Sample Application　　

　　Affinities　　

8　Thread Synchronization in User Mode　　

　　Atomic Access: The Interlocked Family of Functions　　

　　Cache Lines　　

　　Advanced Thread Synchronization　　

　　　A Technique to Avoid　　

　　Critical Sections　　

　　　Critical Sections: The Fine Print　　

　　　Critical Sections and Spinlocks　　

　　　Critical Sections and Error Handling　　

　　Slim Reader-Writer Locks　　

　　Condition Variables　　

　　　The Queue Sample Application　　

　　　Useful Tips and Techniques　　

9　Thread Synchronization with Kernel Objects　　

　　Wait Functions　　

　　Successful Wait Side Effects　　

　　Event Kernel Objects　　

　　　The Handshake Sample Application　　

　　Waitable Timer Kernel Objects　　

　　　Having Waitable Timers Queue APC Entries　　

　　　Timer Loose Ends　　

　　Semaphore Kernel Objects　　

　　Mutex Kernel Objects　　

　　　Abandonment Issues　　

　　　Mutexes vs　　Critical Sections　　

　　　The Queue Sample Application　　

　　A Handy Thread Synchronization Object Chart　　

　　Other Thread Synchronization Functions　　

　　　Asynchronous Device I/O　　

　　　WaitForInputIdle　　

　　　MsgWaitForMultipleObjects(Ex)　　

　　　WaitForDebugEvent　　

　　　SignalObjectAndWait　　

　　　Detecting Deadlocks with the Wait Chain Traversal API　　

10　Synchronous and Asynchronous Device I/O　　

　　Opening and Closing Devices　　

　　　A Detailed Look at CreateFile　　

　　Working with File Devices　　

　　　Getting a File’s Size　　

　　　Positioning a File Pointer　　

　　　Setting the End of a File　　

　　Performing Synchronous Device I/O　　

　　　Flushing Data to the Device　　

　　　Synchronous I/O Cancellation　　

　　Basics of Asynchronous Device I/O　　

　　　The OVERLAPPED Structure　　

　　　Asynchronous Device I/O Caveats　　

　　　Canceling Queued Device I/O Requests　　

　　Receiving Completed I/O Request Notifications　　

　　　Signaling a Device Kernel Object　　

　　　Signaling an Event Kernel Object　　

　　　Alertable I/O　　

　　　I/O Completion Ports　　

11 The Windows Thread Pool　　

　　Scenario 1: Call a Function Asynchronously　　

　　　Explicitly Controlling a Work Item　　

　　　The Batch Sample Application　　

　　Scenario 2: Call a Function at a Timed Interval　　

　　　The Timed Message Box Sample Application　　

　　Scenario 3: Call a Function When a Single Kernel Object Becomes Signaled　　

　　Scenario 4: Call a Function When Asynchronous I/O Requests Complete　　

　　Callback Termination Actions　　

　　　Customized Thread Pools　　

　　　Gracefully Destroying a Thread Pool: Cleanup Groups　　

12　Fibers　　

　　Working with Fibers　　

　　　The Counter Sample Application　　

Part III　Memory Management

13　Windows Memory Architecture　　

　　A Process’ Virtual Address Space　　

　　How a Virtual Address Space Is Partitioned　　

　　　Null-Pointer Assignment Partition　　

　　　User-Mode Partition　　

　　　Kernel-Mode Partition　　

　　Regions in an Address Space　　

　　Committing Physical Storage Within a Region　　

　　Physical Storage and the Paging File　　

　　　Physical Storage Not Maintained in the Paging File　　

　　Protection Attributes　　

　　　Copy-on-Write Access　　

　　　Special Access Protection Attribute Flags　　

　　Bringing It All Home　　

　　　Inside the Regions　　

　　The Importance of Data Alignment　　

14　Exploring Virtual Memory　　

　　System Information　　

　　　The System Information Sample Application　　

　　Virtual Memory Status　　

　　Memory Management on NUMA Machines　　

　　　The Virtual Memory Status Sample Application　　

　　Determining the State of an Address Space　　

　　　The VMQuery Function　　

　　　The Virtual Memory Map Sample Application　　

15　Using Virtual Memory in Your Own Applications　　

　　Reserving a Region in an Address Space　　

　　Committing Storage in a Reserved Region　　

　　Reserving a Region and Committing Storage Simultaneously　　

　　When to Commit Physical Storage　　

　　Decommitting Physical Storage and Releasing a Region　　

　　　When to Decommit Physical Storage　　

　　　The Virtual Memory Allocation Sample Application　　

　　Changing Protection Attributes　　

　　Resetting the Contents of Physical Storage　　

　　　The MemReset Sample Application　　

　　Address Windowing Extensions　　

　　　The AWE Sample Application　　

16　A Thread’s Stack　　

　　The C/C++ Run-Time Library’s Stack-Checking Function　　

　　The Summation Sample Application　　

17　Memory-Mapped Files　　

　　Memory-Mapped Executables and DLLs　　

　　　Static Data Is Not Shared by Multiple Instances of an Executable or a DLL　　

　　Memory-Mapped Data Files　　

　　　Method 1: One File, One Buffer　　

　　　Method 2: Two Files, One Buffer　　

　　　Method 3: One File, Two Buffers　　

　　　Method 4: One File, Zero Buffers　　

　　Using Memory-Mapped Files　　

　　　Step 1: Creating or Opening a File Kernel Object　　

　　　Step 2: Creating a File-Mapping Kernel Object　　

　　　Step 3: Mapping the File’s Data into the Process’ Address Space　　

　　　Step 4: Unmapping the File’s Data from the Process’ Address Space　　

　　　Steps 5　　and 6: Closing the File-Mapping Object and the File Object　　

　　　The File Reverse Sample Application　　

　　Processing a Big File Using Memory-Mapped Files　　

　　Memory-Mapped Files and Coherence　　

　　Specifying the Base Address of a Memory-Mapped File　　

　　Implementation Details of Memory-Mapped Files　　

　　Using Memory-Mapped Files to Share Data Among Processes　　

　　Memory-Mapped Files Backed by the Paging File　　

　　　The Memory-Mapped File Sharing Sample Application　　

　　Sparsely Committed Memory-Mapped Files　　

　　　The Sparse Memory-Mapped File Sample Application　　

18　Heaps　　

　　A Process’ Default Heap　　

　　Reasons to Create Additional Heaps　　

　　　Component Protection　　

　　　More Efficient Memory Management　　

　　　Local Access　　

　　　Avoiding Thread Synchronization Overhead　　

　　　Quick Free　　

　　How to Create an Additional Heap　　

　　　Allocating a Block of Memory from a Heap　　

　　　Changing the Size of a Block　　

　　　Obtaining the Size of a Block　　

　　　Freeing a Block　　

　　　Destroying a Heap　　

　　　Using Heaps with C++　　

　　Miscellaneous Heap Functions　　

Part IV　Dynamic-Link Libraries

19　DLL Basics　　

　　DLLs and a Process’ Address Space　　

　　The Overall Picture　　

　　　Building the DLL Module　　

　　　Building the Executable Module　　

　　　Running the Executable Module　　

20　DLL Advanced Techniques　　

　　Explicit DLL Module Loading and Symbol Linking　　

　　　Explicitly Loading the DLL Module　　

　　　Explicitly Unloading the DLL Module　　

　　　Explicitly Linking to an Exported Symbol　　

　　The DLL’s Entry-Point Function　　

　　　The DLL_PROCESS_ATTACH Notification　　

　　　The DLL_PROCESS_DETACH Notification　　

　　　The DLL_THREAD_ATTACH Notification　　

　　　The DLL_THREAD_DETACH Notification　　

　　　Serialized Calls to DllMain　　

　　　DllMain and the C/C++ Run-Time Library　　

　　Delay-Loading a DLL　　

　　　The DelayLoadApp Sample Application　　

　　Function Forwarders　　

　　Known DLLs　　

　　DLL Redirection　　

　　Rebasing Modules　　

　　Binding Modules　　

21　Thread-Local Storage　　

　　Dynamic TLS　　

　　　Using Dynamic TLS　　

　　Static TLS　　

22　DLL Injection and API Hooking　　

　　DLL Injection: An Example　　

　　Injecting a DLL Using the Registry　　

　　Injecting a DLL Using Windows Hooks　　

　　　The Desktop Item Position Saver (DIPS) Utility　　

　　Injecting a DLL Using Remote Threads　　

　　　The Inject Library Sample Application　　

　　　The Image Walk DLL　　

　　Injecting a DLL with a Trojan DLL　　

　　Injecting a DLL as a Debugger　　

　　Injecting Code with CreateProcess　　

　　API Hooking: An Example　　

　　　API Hooking by Overwriting Code　　

　　　API Hooking by Manipulating a Module’s Import Section　　

　　　The Last MessageBox Info Sample Application　　

Part V　Structured Exception Handling

23　　Termination Handlers　　

　　Understanding Termination Handlers by Example　　

　　　Funcenstein1　　

　　　Funcenstein2　　

　　　Funcenstein3　　

　　　Funcfurter1　　

　　　Pop Quiz Time: FuncaDoodleDoo　　

　　　Funcenstein4　　

　　　Funcarama1　　

　　　Funcarama2　　

　　　Funcarama3　　

　　　Funcarama4: The Final Frontier　　

　　　Notes About the finally Block　　

　　　Funcfurter2　　

　　　The SEH Termination Sample Application　　

24　Exception Handlers and Software Exceptions　　

　　Understanding Exception Filters and Exception Handlers by Example　　

　　　Funcmeister1　　

　　　Funcmeister2　　

　　EXCEPTION_EXECUTE_HANDLER　　

　　　Some Useful Examples　　

　　　Global Unwinds　　

　　　Halting Global Unwinds　　

　　EXCEPTION_CONTINUE_EXECUTION　　

　　　Use EXCEPTION_CONTINUE_EXECUTION with Caution　　

　　EXCEPTION_CONTINUE_SEARCH　　

　　GetExceptionCode　　

　　　Memory-Related Exceptions　　

　　　Exception-Related Exceptions　　

　　　Debugging-Related Exceptions　　

　　　Integer-Related Exceptions　　

　　　Floating Point–Related Exceptions　　

　　GetExceptionInformation　　

　　Software Exceptions　　

25　Unhandled Exceptions, Vectored Exception Handling, and C++ Exceptions　　

　　Inside the UnhandledExceptionFilter Function　　

　　　Action #1: Allowing Write Access to a Resource and Continuing Execution　　

　　　Action #2: Notifying a Debugger of the Unhandled Exception　　

　　　Action #3: Notifying Your Globally Set Filter Function　　

　　　Action #4: Notifying a Debugger of the Unhandled Exception (Again)　　

　　　Action #5: Silently Terminating the Process　　

　　　UnhandledExceptionFilter and WER Interactions　　

　　Just-in-Time Debugging　　

　　The Spreadsheet Sample Application　　

　　Vectored Exception and Continue Handlers　　

　　C++ Exceptions vs　　Structured Exceptions　　

　　Exceptions and the Debugger　　

26　Error Reporting and Application Recovery　　

　　The Windows Error Reporting Console　　

　　Programmatic Windows Error Reporting　　

　　　Disabling Report Generation and Sending　　

　　Customizing All Problem Reports Within a Process　　

　　Creating and Customizing a Problem Report　　

　　　Creating a Custom Problem Report: WerReportCreate　　

　　　Setting Report Parameters: WerReportSetParameter　　

　　　Adding a Minidump File to the Report: WerReportAddDump　　

　　　Adding Arbitrary Files to the Report: WerReportAddFile　　

　　　Modifying Dialog Box Strings: WerReportSetUIOption　　

　　　Submitting a Problem Report: WerReportSubmit　　

　　　Closing a Problem Report: WerReportCloseHandle　　

　　　The Customized WER Sample Application　　

　　Automatic Application Restart and Recovery　　

　　　Automatic Application Restart　　

　　　Support for Application Recovery　　

Part VI　Appendixes

A　The Build Environment　　

　　The CmnHdr.h Header File　　

　　　Microsoft Windows Version Build Option　　

　　　Unicode Build Option　　

　　　Windows Definitions and Warning Level 4　　

　　　The pragma message Helper Macro　　

　　　The chINRANGE Macro　　

　　　The chBEGINTHREADEX Macro　　

　　　DebugBreak Improvement for x86　　Platforms　　

　　　Creating Software Exception Codes　　

　　　The chMB Macro　　

　　　The chASSERT and chVERIFY Macros　　

　　　The chHANDLE_DLGMSG Macro　　

　　　The chSETDLGICONS Macro　　

　　　Forcing the Linker to Look for a (w)WinMain Entry-Point Function　　

　　　Support XP-Theming of the User Interface with pragma　　

B　Message Crackers, Child Control Macros, and API Macros　　

　　Message Crackers　　

　　Child Control Macros　　

　　API Macros　　

Index