Windows的复合文件技术

      今天初步学习了复合文件的一些知识，对于该知识点，由于涉及COM的一些原理，暂时还不理解，这个文档就是将暂时了解的一些内容，组织成一篇学习笔记，供以后参考.

      在Microsoft的Word,Excel等应用程序中，保存文件的格式是用复合结构来保存的.复合结构不像一般的文件存储方式（根目录、子目录、文件形式的结构），而是采用根存储(IStorage类型),子存储(IStorage类型),流(IStream)结构的形式来存储文件.

      复合文件中的流，是保存数据的空间，存储单位是512字节.

      不同进程，不同线程可以访问复合文件的不同部分而不受干扰.这在不同于普通文件的特点之处.

      复合文件提供了增量访问的能力，在一个文件中插入某些字节不需要对整个文件进行访问.

      在VC6中有一工具提供了查看复合文件的功能，是Doc File View工具.可以用它来查看复合文件的结构内容.

      操作复合文件的函数，分为三种类型，WinAPI函数，存储IStorage接口函数，流IStream接口函数.

WINAPI函数：
    StgCreateDocFile() 建立复合文件，得到根存储对象
    StgOpenStorage()    打开复合文件，得到根存储对象
    StgIsStorageFile() 判断文件是否复合文件

IStorage函数
    CreateStorage() 在当前存储中建立新存储，得到子存储对象
    CreateStream() 在当前存储中建立流，得到流对象
    OpenStorage()   打开子存储，得到子存储对象
    OpenStream()    打开流，得到流对象
    CopyTo() MoveElementTo() DestoryElement() RenameElement() EnumElements() SetElementTimes() SetClass() Stat() Release() 等等

    IStream函数
    Read() Write() Seek() SetSize() CopyTo() Stat() Clone() Release()

    关于这些函数有很好的教程：http://www.vckbase.com/document/viewdoc/?id=1483

MSDN文章上面有一代码，描述了如何具体的创建和设置Storage File的方法，很好的一个例子，值得学习.

例子如下：

/*The EnumAll.cpp sample program dumps all the properties in all property sets of a storage file.*/
2

//+============================================================================
4

//
5

// To Build: cl /GX enumall.cpp
6

//
7

// This sample is a program which dumps all the properties in all property
8

// sets of a storage file.
9

//
10

//+============================================================================
11

#define UNICODE
14

#define _UNICODE
15

#include <stdio.h>
17

#include <windows.h>
18

#pragma comment( lib, "ole32.lib" )
20

//+----------------------------------------------------------------------------
22

//
23

// ConvertVarTypeToString
24

//
25

// Generate a string for a given PROPVARIANT variable type (VT).
26

// For the given vt, write the string to pwszType, which is a buffer of
27

// size cchType characters.
28

//
29

//+----------------------------------------------------------------------------
30

void
32

ConvertVarTypeToString( VARTYPE vt, WCHAR *pwszType, ULONG cchType )
33

{
34

const WCHAR *pwszModifier;
35

// Make sure the output string will be terminated
37

// (wcsncpy doesn't guarantee termination)
38

pwszType[ cchType-1 ] = L'\0';
40

--cchType;
41

// Stringize the basic type
43

switch( vt & VT_TYPEMASK )
45

{
46

case VT_EMPTY:
47

wcsncpy( pwszType, L"VT_EMPTY", cchType );
48

break;
49

case VT_NULL:
50

wcsncpy( pwszType, L"VT_NULL", cchType );
51

break;
52

case VT_I2:
53

wcsncpy( pwszType, L"VT_I2", cchType );
54

break;
55

case VT_I4:
56

wcsncpy( pwszType, L"VT_I4", cchType );
57

break;
58

case VT_I8:
59

wcsncpy( pwszType, L"VT_I8", cchType );
60

break;
61

case VT_UI2:
62

wcsncpy( pwszType, L"VT_UI2", cchType );
63

break;
64

case VT_UI4:
65

wcsncpy( pwszType, L"VT_UI4", cchType );
66

break;
67

case VT_UI8:
68

wcsncpy( pwszType, L"VT_UI8", cchType );
69

break;
70

case VT_R4:
71

wcsncpy( pwszType, L"VT_R4", cchType );
72

break;
73

case VT_R8:
74

wcsncpy( pwszType, L"VT_R8", cchType );
75

break;
76

case VT_CY:
77

wcsncpy( pwszType, L"VT_CY", cchType );
78

break;
79

case VT_DATE:
80

wcsncpy( pwszType, L"VT_DATE", cchType );
81

break;
82

case VT_BSTR:
83

wcsncpy( pwszType, L"VT_BSTR", cchType );
84

break;
85

case VT_ERROR:
86

wcsncpy( pwszType, L"VT_ERROR", cchType );
87

break;
88

case VT_BOOL:
89

wcsncpy( pwszType, L"VT_BOOL", cchType );
90

break;
91

case VT_VARIANT:
92

wcsncpy( pwszType, L"VT_VARIANT", cchType );
93

break;
94

case VT_DECIMAL:
95

wcsncpy( pwszType, L"VT_DECIMAL", cchType );
96

break;
97

case VT_I1:
98

wcsncpy( pwszType, L"VT_I1", cchType );
99

break;
100

case VT_UI1:
101

wcsncpy( pwszType, L"VT_UI1", cchType );
102

break;
103

case VT_INT:
104

wcsncpy( pwszType, L"VT_INT", cchType );
105

break;
106

case VT_UINT:
107

wcsncpy( pwszType, L"VT_UINT", cchType );
108

break;
109

case VT_VOID:
110

wcsncpy( pwszType, L"VT_VOID", cchType );
111

break;
112

case VT_SAFEARRAY:
113

wcsncpy( pwszType, L"VT_SAFEARRAY", cchType );
114

break;
115

case VT_USERDEFINED:
116

wcsncpy( pwszType, L"VT_USERDEFINED", cchType );
117

break;
118

case VT_LPSTR:
119

wcsncpy( pwszType, L"VT_LPSTR", cchType );
120

break;
121

case VT_LPWSTR:
122

wcsncpy( pwszType, L"VT_LPWSTR", cchType );
123

break;
124

case VT_RECORD:
125

wcsncpy( pwszType, L"VT_RECORD", cchType );
126

break;
127

case VT_FILETIME:
128

wcsncpy( pwszType, L"VT_FILETIME", cchType );
129

break;
130

case VT_BLOB:
131

wcsncpy( pwszType, L"VT_BLOB", cchType );
132

break;
133

case VT_STREAM:
134

wcsncpy( pwszType, L"VT_STREAM", cchType );
135

break;
136

case VT_STORAGE:
137

wcsncpy( pwszType, L"VT_STORAGE", cchType );
138

break;
139

case VT_STREAMED_OBJECT:
140

wcsncpy( pwszType, L"VT_STREAMED_OBJECT", cchType );
141

break;
142

case VT_STORED_OBJECT:
143

wcsncpy( pwszType, L"VT_BLOB_OBJECT", cchType );
144

break;
145

case VT_CF:
146

wcsncpy( pwszType, L"VT_CF", cchType );
147

break;
148

case VT_CLSID:
149

wcsncpy( pwszType, L"VT_CLSID", cchType );
150

break;
151

default:
152

_snwprintf( pwszType, cchType, L"Unknown (%d)", vt & VT_TYPEMASK );
153

break;
154

}
155

156

// Adjust cchType for the characters we just added
157

158

cchType -= wcslen(pwszType);
159

160

// Add the type modifiers if present
161

162

if( vt & VT_VECTOR )
163

{
164

pwszModifier = L" | VT_VECTOR";
165

wcsncat( pwszType, pwszModifier, cchType );
166

cchType -= wcslen( pwszModifier );
167

}
168

169

if( vt & VT_ARRAY )
170

{
171

pwszModifier = L" | VT_ARRAY";
172

wcsncat( pwszType, pwszModifier, cchType );
173

cchType -= wcslen( pwszModifier );
174

}
175

176

if( vt & VT_RESERVED )
177

{
178

pwszModifier = L" | VT_RESERVED";
179

wcsncat( pwszType, pwszModifier, cchType );
180

cchType -= wcslen( pwszModifier );
181

}
182

183

}
184

185

186

//+----------------------------------------------------------------------------
187

//
188

// ConvertValueToString
189

//
190

// Generate a string for the value in a given PROPVARIANT structure.
191

// The most common types are supported (that is, those that can be displayed
192

// with printf). For other types, only an ellipses "

" is displayed.
193

//
194

// The property to string-ize is in propvar, the resulting string goes
195

// into pwszValue, which is a buffer with room for cchValue characters
196

// (including the string terminator).
197

//
198

//+----------------------------------------------------------------------------
199

200

void
201

ConvertValueToString( const PROPVARIANT &propvar,
202

WCHAR *pwszValue,
203

ULONG cchValue )
204

{
205

// Make sure the output string will be terminated
206

207

pwszValue[ cchValue - 1 ] = L'\0';
208

--cchValue;
209

210

// Based on the type, put the value into pwszValue as a string.
211

212

switch( propvar.vt )
213

{
214

case VT_EMPTY:
215

wcsncpy( pwszValue, L"", cchValue );
216

break;
217

case VT_NULL:
218

wcsncpy( pwszValue, L"", cchValue );
219

break;
220

case VT_I2:
221

_snwprintf( pwszValue, cchValue, L"%i", propvar.iVal );
222

break;
223

case VT_I4:
224

case VT_INT:
225

_snwprintf( pwszValue, cchValue, L"%li", propvar.lVal );
226

break;
227

case VT_I8:
228

_snwprintf( pwszValue, cchValue, L"%I64i", propvar.hVal );
229

break;
230

case VT_UI2:
231

_snwprintf ( pwszValue, cchValue, L"%u", propvar.uiVal );
232

break;
233

case VT_UI4:
234

case VT_UINT:
235

_snwprintf ( pwszValue, cchValue, L"%lu", propvar.ulVal );
236

break;
237

case VT_UI8:
238

_snwprintf ( pwszValue, cchValue, L"%I64u", propvar.uhVal );
239

break;
240

case VT_R4:
241

_snwprintf ( pwszValue, cchValue, L"%f", propvar.fltVal );
242

break;
243

case VT_R8:
244

_snwprintf ( pwszValue, cchValue, L"%lf", propvar.dblVal );
245

break;
246

case VT_BSTR:
247

_snwprintf ( pwszValue, cchValue, L"\"%s\"", propvar.bstrVal );
248

break;
249

case VT_ERROR:
250

_snwprintf ( pwszValue, cchValue, L"0x%08X", propvar.scode );
251

break;
252

case VT_BOOL:
253

_snwprintf ( pwszValue, cchValue, L"%s",
254

VARIANT_TRUE == propvar.boolVal ? L"True" : L"False" );
255

break;
256

case VT_I1:
257

_snwprintf ( pwszValue, cchValue, L"%i", propvar.cVal );
258

break;
259

case VT_UI1:
260

_snwprintf ( pwszValue, cchValue, L"%u", propvar.bVal );
261

break;
262

case VT_VOID:
263

wcsncpy( pwszValue, L"", cchValue );
264

break;
265

case VT_LPSTR:
266

if( 0 >_snwprintf ( pwszValue, cchValue, L"\"%hs\"", propvar.pszVal ))
267

// String is too big for pwszValue
268

wcsncpy( pwszValue, L"

", cchValue );
269

break;
270

case VT_LPWSTR:
271

if( 0 > _snwprintf ( pwszValue, cchValue, L"\"%s\"", propvar.pwszVal ))
272

// String is too big for pwszValue
273

wcsncpy( pwszValue, L"

", cchValue );
274

break;
275

case VT_FILETIME:
276

_snwprintf ( pwszValue, cchValue, L"%08x:%08x",
277

propvar.filetime.dwHighDateTime,
278

propvar.filetime.dwLowDateTime );
279

break;
280

case VT_CLSID:
281

pwszValue[0] = L'\0';
282

StringFromGUID2( *propvar.puuid, pwszValue, cchValue );
283

break;
284

default:
285

wcsncpy( pwszValue, L"

", cchValue );
286

break;
287

}
288

289

}
290

291

292

//+----------------------------------------------------------------------------
293

//
294

// DisplayProperty
295

//
296

// Dump the ID, name, type, and value of a property.
297

//
298

//+----------------------------------------------------------------------------
299

300

void
301

DisplayProperty( const PROPVARIANT &propvar, const STATPROPSTG &statpropstg )
302

{
303

WCHAR wsz[ MAX_PATH + 1 ];
304

305

ConvertVarTypeToString( statpropstg.vt, wsz, sizeof(wsz)/sizeof(wsz[0]) );
306

307

wprintf( L" ----------------------------------------------------\n"
308

L" PropID = %-5d VarType = %-23s",
309

statpropstg.propid, wsz );
310

311

if( NULL != statpropstg.lpwstrName )
312

wprintf( L" Name = %s", statpropstg.lpwstrName );
313

314

ConvertValueToString( propvar, wsz, sizeof(wsz)/sizeof(wsz[0]) );
315

316

wprintf( L"\n Value = %s\n", wsz );
317

318

}
319

320

321

//+----------------------------------------------------------------------------
322

//
323

// DisplayPropertySet
324

//
325

// Dump all the properties into a given property set.
326

//
327

//+----------------------------------------------------------------------------
328

329

void
330

DisplayPropertySet( FMTID fmtid,
331

const WCHAR *pwszStorageName,
332

IPropertyStorage *pPropStg )
333

{
334

IEnumSTATPROPSTG *penum = NULL;
335

HRESULT hr = S_OK;
336

STATPROPSTG statpropstg;
337

PROPVARIANT propvar;
338

PROPSPEC propspec;
339

PROPID propid;
340

WCHAR *pwszFriendlyName = NULL;
341

342

// This string will hold a string-ized FMTID. It needs
343

// to be 38 characters, plus the terminator
344

// character. But just to be safe we'll make
345

// it a little bigger.
346

WCHAR wszFMTID[ 64 ] = { L"" };
347

348

PropVariantInit( &propvar );
349

memset( &statpropstg, 0, sizeof(statpropstg) );
350

351

try
352

{
353

// Display the ID of the property set
354

355

StringFromGUID2( fmtid,
356

wszFMTID,
357

sizeof(wszFMTID)/sizeof(wszFMTID[0]) );
358

wprintf( L"\n Property Set %s\n", wszFMTID );
359

360

// If this is one of common property sets, show which one.
361

362

if( FMTID_SummaryInformation == fmtid )
363

wprintf( L" (SummaryInformation property set)\n" );
364

else if( FMTID_DocSummaryInformation == fmtid )
365

wprintf( L" (DocumentSummaryInformation property set)\n" );
366

else if( FMTID_UserDefinedProperties == fmtid )
367

wprintf( L" (UserDefined property set)\n" );
368

369

// Also display the name of the storage that contains
370

// this property set
371

372

wprintf( L" in \"%s\":\n", pwszStorageName );
373

374

// If this property set has a friendly name, display it now.
375

// (Property names are stored in the special dictionary
376

// property - the name of the property set is indicated by naming
377

// the dictionary property itself.)
378

379

propid = PID_DICTIONARY;
380

pwszFriendlyName = NULL;
381

382

hr = pPropStg->ReadPropertyNames( 1, &propid, &pwszFriendlyName );
383

if( S_OK == hr )
384

{
385

wprintf( L" (Friendly name is \"%s\")\n\n", pwszFriendlyName );
386

CoTaskMemFree( pwszFriendlyName );
387

pwszFriendlyName = NULL;
388

}
389

else
390

wprintf( L"\n" );
391

392

// Get a property enumerator
393

394

hr = pPropStg->Enum( &penum );
395

if( FAILED(hr) ) throw L"Failed IPropertyStorage::Enum";
396

397

// Get the first property in the enumeration
398

399

hr = penum->Next( 1, &statpropstg, NULL );
400

401

// Loop through and display each property. The ‘Next'
402

// call above (and at the bottom of the while loop)
403

// will return S_OK if it returns another property,
404

// S_FALSE if there are no more properties,
405

// and anything else is an error.
406

407

while( S_OK == hr )
408

{
409

410

// Read the property out of the property set
411

412

PropVariantInit( &propvar );
413

propspec.ulKind = PRSPEC_PROPID;
414

propspec.propid = statpropstg.propid;
415

416

hr = pPropStg->ReadMultiple( 1, &propspec, &propvar );
417

if( FAILED(hr) ) throw L"Failed IPropertyStorage::ReadMultiple";
418

419

// Display the property value, type, etc.
420

421

DisplayProperty( propvar, statpropstg );
422

423

// Free buffers that were allocated during the read and
424

// by the enumerator.
425

426

PropVariantClear( &propvar );
427

CoTaskMemFree( statpropstg.lpwstrName );
428

statpropstg.lpwstrName = NULL;
429

430

// Move to the next property in the enumeration
431

432

hr = penum->Next( 1, &statpropstg, NULL );
433

}
434

if( FAILED(hr) ) throw L"Failed IEnumSTATPROPSTG::Next";
435

}
436

catch( LPCWSTR pwszErrorMessage )
437

{
438

wprintf( L"Error in DumpPropertySet: %s (hr = %08x)\n",
439

pwszErrorMessage, hr );
440

}
441

442

if( NULL != penum )
443

penum->Release();
444

445

if( NULL != statpropstg.lpwstrName )
446

CoTaskMemFree( statpropstg.lpwstrName );
447

448

PropVariantClear( &propvar );
449

}
450

451

452

//+----------------------------------------------------------------------------
453

//
454

// DisplayPropertySetsInStorage
455

//
456

// Dump the property sets in the top level of a given storage.
457

//
458

//+----------------------------------------------------------------------------
459

460

void
461

DisplayPropertySetsInStorage( const WCHAR *pwszStorageName,
462

IPropertySetStorage *pPropSetStg )
463

{
464

IEnumSTATPROPSETSTG *penum = NULL;
465

HRESULT hr = S_OK;
466

IPropertyStorage *pPropStg = NULL;
467

STATPROPSETSTG statpropsetstg;
468

469

try
470

{
471

// Get a property-set enumerator (which only enumerates the property
472

// sets at this level of the storage, not its children).
473

474

hr = pPropSetStg->Enum( &penum );
475

if( FAILED(hr) ) throw L"failed IPropertySetStorage::Enum";
476

477

// Get the first property set in the enumeration.
478

// (The field we're interested in is
479

// statpropsetstg.fmtid, so that we can open the
480

// property set.)
481

482

memset( &statpropsetstg, 0, sizeof(statpropsetstg) );
483

hr = penum->Next( 1, &statpropsetstg, NULL );
484

485

// Loop through all the property sets
486

487

while( S_OK == hr )
488

{
489

// Open the property set
490

491

hr = pPropSetStg->Open( statpropsetstg.fmtid,
492

STGM_READ | STGM_SHARE_EXCLUSIVE,
493

&pPropStg );
494

if( FAILED(hr) ) throw L"failed IPropertySetStorage::Open";
495

496

// Display the properties in the property set
497

498

DisplayPropertySet( statpropsetstg.fmtid,
499

pwszStorageName,
500

pPropStg );
501

502

pPropStg->Release();
503

pPropStg = NULL;
504

505

// Get the FMTID of the next property set in the enumeration.
506

507

hr = penum->Next( 1, &statpropsetstg, NULL );
508

509

}
510

if( FAILED(hr) ) throw L"Failed IEnumSTATPROPSETSTG::Next";
511

512

// Special-case handling for the UserDefined property set:
513

// This property set actually lives inside the well-known
514

// DocumentSummaryInformation property set. It is the only
515

// property set which is allowed to live inside another
516

// (and exists for legacy compatibility). It does not get
517

// included in a normal enumeration, so we have to check for
518

// it explicitely. We'll handle it by looking for it when
519

// we reach the end of the enumerator.
520

521

hr = pPropSetStg->Open( FMTID_UserDefinedProperties,
522

STGM_READ | STGM_SHARE_EXCLUSIVE,
523

&pPropStg );
524

if( SUCCEEDED(hr) )
525

{
526

DisplayPropertySet( FMTID_UserDefinedProperties,
527

pwszStorageName,
528

pPropStg );
529

pPropStg = NULL;
530

}
531

532

}
533

catch( LPCWSTR pwszErrorMessage )
534

{
535

wprintf( L"Error in DumpPropertySetsInStorage: %s (hr = %08x)\n",
536

pwszErrorMessage, hr );
537

}
538

539

if( NULL != pPropStg )
540

pPropStg->Release();
541

if( NULL != penum )
542

penum->Release();
543

}
544

545

546

//+----------------------------------------------------------------------------
547

//
548

// DisplayStorageTree
549

//
550

// Dump all the property sets in the given storage and recursively in
551

// all its children.
552

//
553

//+----------------------------------------------------------------------------
554

555

void
556

DisplayStorageTree( const WCHAR *pwszStorageName, IStorage *pStg )
557

{
558

IPropertySetStorage *pPropSetStg = NULL;
559

IStorage *pStgChild = NULL;
560

WCHAR *pwszChildStorageName = NULL;
561

IEnumSTATSTG *penum = NULL;
562

HRESULT hr = S_OK;
563

STATSTG statstg;
564

565

memset( &statstg, 0, sizeof(statstg) );
566

567

try
568

{
569

// Dump the property sets at this storage level
570

571

hr = pStg->QueryInterface( IID_IPropertySetStorage,
572

reinterpret_cast<void**>(&pPropSetStg) );
573

if( FAILED(hr) )
574

throw L"Failed IStorage::QueryInterface(IID_IPropertySetStorage)";
575

576

DisplayPropertySetsInStorage( pwszStorageName, pPropSetStg );
577

578

// Get an enumerator for this storage.
579

580

hr = pStg->EnumElements( NULL, NULL, NULL, &penum );
581

if( FAILED(hr) ) throw L"failed IStorage::Enum";
582

583

// Get the name of the first element (stream/storage)
584

// in the enumeration. As usual, ‘Next' will return
585

// S_OK if it returns an element of the enumerator,
586

// S_FALSE if there are no more elements, and an
587

// error otherwise.
588

589

hr = penum->Next( 1, &statstg, 0 );
590

591

// Loop through all the direct children of this storage.
592

593

while( S_OK == hr )
594

{
595

// Check if this is a storage that isn't a property set
596

// (since we already displayed the property sets above).
597

// You can tell if a stream/storage is a property set
598

// because the first character of it's name is the
599

// ‘\005' reserved character.
600

601

if( STGTY_STORAGE == statstg.type
602

&&
603

L'\005' != statstg.pwcsName[0] )
604

{
605

// Yes, this is a normal storage, not a propset.
606

// Open the storage.
607

608

ULONG cchChildStorageName;
609

610

hr = pStg->OpenStorage( statstg.pwcsName,
611

NULL,
612

STGM_READ | STGM_SHARE_EXCLUSIVE,
613

NULL, 0,
614

&pStgChild );
615

if( FAILED(hr) ) throw L"failed IStorage::OpenStorage";
616

617

// Compose a name of the form "Storage\ChildStorage\

"
618

// for display purposes. First, allocate it.
619

620

cchChildStorageName = wcslen(pwszStorageName)
621

+ wcslen(statstg.pwcsName)
622

+ 2 // For the two "\" chars
623

+ 1; // For the string terminator
624

625

pwszChildStorageName = new WCHAR[ cchChildStorageName ];
626

if( NULL == pwszChildStorageName )
627

{
628

hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
629

throw L"couldn't allocate memory";
630

}
631

632

// Terminate the name
633

634

pwszChildStorageName[ cchChildStorageName-1 ] = L'\0';
635

--cchChildStorageName;
636

637

// Build the name.
638

639

wcsncpy( pwszChildStorageName, pwszStorageName,
640

cchChildStorageName );
641

cchChildStorageName -= wcslen(pwszStorageName);
642

643

wcsncat( pwszChildStorageName, L"\\",
644

cchChildStorageName );
645

cchChildStorageName -= 2;
646

647

wcsncat( pwszChildStorageName, statstg.pwcsName,
648

cchChildStorageName );
649

650

// Dump all the property sets under this child storage.
651

652

DisplayStorageTree( pwszChildStorageName, pStgChild );
653

654

pStgChild->Release();
655

pStgChild = NULL;
656

657

delete pwszChildStorageName;
658

pwszChildStorageName = NULL;
659

}
660

661

// Move on to the next element in the enumeration of this storage.
662

663

CoTaskMemFree( statstg.pwcsName );
664

statstg.pwcsName = NULL;
665

666

hr = penum->Next( 1, &statstg, 0 );
667

}
668

if( FAILED(hr) ) throw L"failed IEnumSTATSTG::Next";
669

}
670

catch( LPCWSTR pwszErrorMessage )
671

{
672

wprintf( L"Error in DumpStorageTree: %s (hr = %08x)\n",
673

pwszErrorMessage, hr );
674

}
675

676

// Clean up before returning.
677

678

if( NULL != statstg.pwcsName )
679

CoTaskMemFree( statstg.pwcsName );
680

if( NULL != pStgChild )
681

pStgChild->Release();
682

if( NULL != pStg )
683

pStg->Release();
684

if( NULL != penum )
685

penum->Release();
686

if( NULL != pwszChildStorageName )
687

delete pwszChildStorageName;
688

689

}
690

691

692

//+----------------------------------------------------------------------------
693

//
694

// wmain
695

//
696

// Dump all the property sets in a file which is a storage.
697

//
698

//+----------------------------------------------------------------------------
699

700

extern "C" void wmain( int cArgs, WCHAR *rgwszArgs[] )
701

{
702

HRESULT hr = S_OK;
703

IStorage *pStg = NULL;
704

705

// Display usage information if necessary.
706

707

if( 1 == cArgs
708

||
709

0 == wcscmp( L"-?", rgwszArgs[1] )
710

||
711

0 == wcscmp( L"/?", rgwszArgs[1] ))
712

{
713

printf( "\n"
714

"Purpose: Enumerate all properties in all\n"
715

" property sets for a storage file\n"
716

"Usage: PropDump <filename>\n"
717

"E.g.: PropDump word.doc\n"
718

"\n" );
719

exit(0);
720

}
721

722

// Open the root storage.
723

724

hr = StgOpenStorageEx( rgwszArgs[1],
725

STGM_READ | STGM_SHARE_DENY_WRITE,
726

STGFMT_ANY,
727

0,
728

NULL,
729

NULL,
730

IID_IStorage,
731

reinterpret_cast<void**>(&pStg) );
732

733

// Dump all the properties in all the property sets within this
734

// storage.
735

736

if( FAILED(hr) )
737

{
738

wprintf( L"Error: couldn't open storage \"%s\" (hr = %08x)\n",
739

rgwszArgs[1], hr );
740

}
741

else
742

{
743

printf( "\nDisplaying all property sets

\n" );
744

DisplayStorageTree( rgwszArgs[1], pStg );
745

pStg->Release();
746

}
747

748

749

}
750

751

posted @ 2007-01-04 20:41 shipfi 阅读(3734) 评论(0) 编辑收藏举报

刷新页面返回顶部

Windows的复合文件技术

公告