9780321256195

The definitive guide to systems programming for Windows XP and 2003 using the essential features and functions of the Windows API.

Johnson M. Hart is a software trainer and consultant specializing in Windows, L inux, and UNIX application development, enhancement, and maintenance. John develops and delivers professional training courses and seminars to clients worldwide, and he is the author of numerous technical articles.

Figures

xvii

Tables

xix

Programs

xxi

Preface

xxv

Getting Started with Win32 and Win64

1

(22)

Operating System Essentials

1

(1)

Windows Evolution

2

(1)

Windows Versions

3

(3)

The Windows Market Role

6

(1)

Windows, Standards, and Open Systems

7

(1)

Windows Principles

8

(3)

Getting Ready for Win64

11

(1)

The Standard C Library: When to Use It for File Processing

12

(1)

What You Need to Use This Book

13

(1)

Example: A Simple Sequential File Copy

13

(6)

Summary

19

(2)

Exercises

21

(2)

Using the Windows File System and Character I/O

23

(32)

The Windows File Systems

24

(1)

File Naming

25

(1)

Opening, Reading, Writing, and Closing Files

26

(6)

Interlude: Unicode and Generic Characters

32

(3)

Unicode Strategies

35

(1)

Standard Devices and Console I/O

35

(4)

Example: Printing and Prompting

39

(2)

Example: Error Processing

41

(2)

Example: Copying Multiple Files to Standard Output

43

(1)

Example: ASCII to Unicode Conversion

44

(2)

File and Directory Management

46

(5)

Example: Printing the Current Directory

51

(1)

Summary

52

(1)

Exercises

53

(2)

Advanced File and Directory Processing, and the Registry

55

(36)

The 64-Bit File System

55

(1)

File Pointers

56

(3)

Getting the File Size

59

(1)

Example: Random Record Updates

60

(3)

File Attributes and Directory Processing

63

(5)

Mount Points

68

(1)

Example: Listing File Attributes

69

(3)

Example: Setting File Times

72

(1)

File Processing Strategies

73

(1)

File Locking

74

(4)

The Registry

78

(2)

Registry Management

80

(4)

Example: Listing Registry Keys and Contents

84

(3)

Summary

87

(1)

Exercises

88

(3)

Exception Handling

91

(28)

Exceptions and Their Handlers

91

(7)

Floating-Point Exceptions

98

(1)

Errors and Exceptions

99

(2)

Example: Treating Errors as Exceptions

101

(2)

Termination Handlers

103

(4)

Example: Using Termination Handlers to Improve Program Quality

107

(2)

Example: Using a Filter Function

109

(3)

Console Control Handlers

112

(2)

Example: A Console Control Handler

114

(1)

Vectored Exception Handling

115

(1)

Summary

116

(1)

Exercises

117

(2)

Memory Management, Memory-Mapped Files, and DLLs

119

(44)

Win32 and Win64 Memory Management Architecture

120

(2)

Heaps

122

(3)

Managing Heap Memory

125

(4)

Example: Sorting Files with a Binary Search Tree

129

(5)

Memory-Mapped Files

134

(6)

Example: Sequential File Processing with Mapped Files

140

(2)

Example: Sorting a Memory-Mapped File

142

(2)

Example: Using Based Pointers

144

(5)

Dynamic Link Libraries

149

(5)

Example: Explicitly Linking a File Conversion Function

154

(2)

The DLL Entry Point

156

(1)

DLL Version Management

157

(1)

Summary

158

(2)

Exercises

160

(3)

Process Management

163

(36)

Windows Processes and Threads

163

(2)

Process Creation

165

(6)

Process Handle Counts

171

(1)

Process Identities

172

(1)

Duplicating Handles

173

(1)

Exiting and Terminating a Process

174

(2)

Waiting for a Process to Terminate

176

(1)

Environment Blocks and Strings

177

(2)

Example: Parallel Pattern Searching

179

(3)

Processes in a Multiprocessor Environment

182

(1)

Process Execution Times

182

(1)

Example: Process Execution Times

183

(2)

Generating Console Control Events

185

(1)

Example: Simple Job Management

186

(8)

Job Objects

194

(1)

Summary

195

(1)

Exercises

196

(3)

Threads and Scheduling

199

(32)

Thread Overview

199

(2)

Thread Basics

201

(1)

Thread Management

202

(5)

Using the C Library in Threads

207

(1)

Example: Multithreaded Pattern Searching

208

(2)

Performance Impact

210

(1)

The Boss/Worker and Other Threading Models

211

(2)

Example: Merge-Sort---Divide and Conquer to Exploit SMP

213

(3)

Thread Local Storage

216

(2)

Process and Thread Priority and Scheduling

218

(2)

Thread States

220

(2)

Pitfalls and Common Mistakes

222

(1)

Timed Waits

223

(1)

Fibers

224

(2)

Summary

226

(1)

Exercises

227

(4)

Thread Synchronization

231

(34)

The Need for Thread Synchronization

231

(5)

Thread Synchronization Objects

236

(1)

The Critical_Section Object

236

(3)

A Critical_Section for Protecting Shared Variables

239

(1)

Example: A Simple Producer/Consumer System

240

(5)

Mutexes

245

(5)

Semaphores

250

(3)

Events

253

(2)

Example: A Producer/Consumer System

255

(4)

More Mutex and Critical_Section Guidelines

259

(1)

More Interlocked Functions

260

(2)

Memory Management Performance Considerations

262

(1)

Summary

262

(1)

Exercises

263

(2)

Synchronization Performance Impact and Guidelines

265

(16)

Synchronization Performance Impact

266

(3)

A Model Program for Performance Experimentation

269

(1)

Tuning SMP Performance with CS Spin Counts

270

(2)

Semaphore ``Throttles'' to Reduce Thread Contention

272

(3)

Processor Affinity

275

(2)

I/O Completion Ports

277

(1)

Performance Guidelines and Pitfalls

277

(2)

Summary

279

(1)

Exercises

279

(2)

Advanced Thread Synchronization

281

(34)

The Condition Variable Model and Safety Properties

281

(6)

Using SignalObjectAndWait

287

(2)

Example: A Threshold Barrier Object

289

(3)

A Queue Object

292

(5)

Example: Using Queues in a Multistage Pipeline

297

(7)

Asynchronous Procedure Calls

304

(1)

Queuing Asynchronous Procedure Calls

305

(1)

Alertable Wait States

306

(2)

Safe Thread Cancellation

308

(1)

Pthreads for Application Portability

308

(1)

Thread Stacks and the Number of Threads

309

(1)

Hints for Designing, Debugging, and Testing

309

(2)

Beyond the Windows API

311

(1)

Summary

312

(1)

Exercises

313

(2)

Interprocess Communication

315

(30)

Anonymous Pipes

316

(1)

Example: I/O Redirection Using an Anonymous Pipe

316

(3)

Named Pipes

319

(6)

Named Pipe Transaction Functions

325

(3)

Example: A Client/Server Command Line Processor

328

(6)

Comments on the Client/Server Command Line Processor

334

(1)

Mailslots

335

(3)

Pipe and Mailslot Creation, Connection, and Naming

338

(1)

Example: A Server That Clients Can Locate

339

(2)

Comments on Thread Models

341

(2)

Summary

343

(1)

Exercises

343

(2)

Network Programming with Windows Sockets

345

(34)

Windows Sockets

346

(2)

Socket Server Functions

348

(4)

Socket Client Functions

352

(2)

Comparing Named Pipes and Sockets

354

(1)

Example: A Socket Message Receive Function

355

(1)

Example: A Socket-Based Client

356

(2)

Example: A Socket-Based Server with New Features

358

(5)

In-Process Servers

363

(2)

Line-Oriented Messages, DLL Entry Points, and TLS

365

(1)

Example: A Thread-Safe DLL for Socket Messages

366

(5)

Example: An Alternative Thread-Safe DLL Strategy

371

(2)

Datagrams

373

(1)

Berkeley Sockets vs. Windows Sockets

374

(1)

Overlapped I/O with Windows Sockets

374

(1)

Windows Sockets 2

375

(1)

Summary

375

(1)

Exercises

376

(3)

Windows Services

379

(22)

Writing Windows Services---Overview

380

(1)

The main() Function

380

(1)

The ServiceMain() Functions

381

(5)

The Service Control Handler

386

(1)

Example: A Service ``Wrapper''

387

(3)

Managing Windows Services

390

(4)

Summary: Service Operation and Management

394

(1)

Example: A Service Control Shell

395

(2)

Sharing Kernel Objects with a Service

397

(1)

Event Logging

398

(1)

Notes on Debugging a Service

398

(1)

Summary

399

(1)

Exercises

400

(1)

Asynchronous Input/Output and Completion Ports

401

(30)

Overview of Windows Asynchronous I/O

402

(1)

Overlapped I/O

402

(5)

Example: Synchronizing on a File Handle

407

(1)

Example: File Conversion with Overlapped I/O and Multiple Buffers

407

(4)

Extended I/O with Completion Routines

411

(4)

Example: File Conversion with Extended I/O

415

(3)

Asynchronous I/O with Threads

418

(1)

Waitable Timers

419

(1)

Example: Using a Waitable Timer

420

(2)

I/O Completion Ports

422

(3)

Example: A Server Using I/O Completion Ports

425

(4)

Summary

429

(1)

Exercises

430

(1)

Securing Windows Objects

431

(26)

Security Attributes

431

(1)

Security Overview: The Security Descriptor

432

(3)

Security Descriptor Control Flags

435

(1)

Security Identifiers

435

(3)

Managing ACLs

438

(1)

Example: UNIX-Style Permission for NTFS Files

439

(3)

Example: Initializing Security Attributes

442

(3)

Reading and Changing Security Descriptors

445

(2)

Example: Reading File Permissions

447

(2)

Example: Changing File Permissions

449

(1)

Securing Kernel and Communication Objects

450

(2)

Example: Securing a Process and Its Threads

452

(1)

Overview of Additional Security Features

452

(2)

Summary

454

(1)

Exercises

455

(2)

Win64 Programming

457

(14)

Current Win64 Status

457

(2)

64-Bit Architecture Overview

459

(2)

The Win64 Programming Model

461

(1)

The Data Types

462

(2)

Legacy Code Migration

464

(2)

Example: Migrating sortMM (Program 5--5)

466

(3)

Summary

469

(1)

Exercises

470

(1)

Appendix A Using the Sample Programs

471

(18)

Web Site Organization

472

(8)

Include File Listings

480

(6)

Additional Utility Programs

486

(3)

Appendix B Windows, UNIX, and C Library Comparisons

489

(16)

File and Directory Management

491

(4)

Exception Handling

495

(1)

Memory Management, Memory-Mapped Files, and DLLs

496

(1)

Process Management

497

(2)

Threads and Scheduling

499

(1)

Thread Synchronization

500

(1)

Interprocess Communication

501

(1)

Asynchronous I/O

502

(1)

Securing Windows Objects

503

(2)

Appendix C Performance Results

505

(14)

Test Configurations

505

(2)

Performance Measurements

507

(11)

Running the Tests

518

(1)

Bibliography

519

(4)

Index

523

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

This book describes application development using the Microsoft 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 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, not 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 (OS) 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 OS 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 OS API, providing a well-understood set of features. Many programmers, regardless of experience level, need to learn Windows 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 libr

Amazon no longer offers textbook rentals. We do!

Windows System Programming

Windows System Programming

0321256190

Summary

Author Biography

Table of Contents

Supplemental Materials

Excerpts