git.oblomov.eu Git - wine/blob - dlls/ole32/stg_prop.c

   1 /*
   2  * Compound Storage (32 bit version)
   3  * Storage implementation
   4  *
   5  * This file contains the compound file implementation
   6  * of the storage interface.
   7  *
   8  * Copyright 1999 Francis Beaudet
   9  * Copyright 1999 Sylvain St-Germain
  10  * Copyright 1999 Thuy Nguyen
  11  * Copyright 2005 Mike McCormack
  12  * Copyright 2005 Juan Lang
  13  *
  14  * This library is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Lesser General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2.1 of the License, or (at your option) any later version.
  18  *
  19  * This library is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public
  25  * License along with this library; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  27  *
  28  * There's a decent overview of property set storage here:
  29  * http://msdn.microsoft.com/archive/en-us/dnarolegen/html/msdn_propset.asp
  30  * It's a little bit out of date, and more definitive references are given
  31  * below, but it gives the best "big picture" that I've found.
  32  *
  33  * TODO:
  34  * - I don't honor the maximum property set size.
  35  * - Certain bogus files could result in reading past the end of a buffer.
  36  * - Mac-generated files won't be read correctly, even if they're little
  37  *   endian, because I disregard whether the generator was a Mac.  This means
  38  *   strings will probably be munged (as I don't understand Mac scripts.)
  39  * - Not all PROPVARIANT types are supported.
  40  * - User defined properties are not supported, see comment in
  41  *   PropertyStorage_ReadFromStream
  42  */
  43
  44 #include <assert.h>
  45 #include <stdarg.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49
  50 #define COBJMACROS
  51 #define NONAMELESSUNION
  52 #define NONAMELESSSTRUCT
  53
  54 #include "windef.h"
  55 #include "winbase.h"
  56 #include "winnls.h"
  57 #include "winuser.h"
  58 #include "wine/unicode.h"
  59 #include "wine/debug.h"
  60 #include "dictionary.h"
  61 #include "storage32.h"
  62 #include "enumx.h"
  63
  64 WINE_DEFAULT_DEBUG_CHANNEL(storage);
  65
  66 static inline StorageImpl *impl_from_IPropertySetStorage( IPropertySetStorage *iface )
  67 {
  68     return (StorageImpl *)((char*)iface - FIELD_OFFSET(StorageImpl, base.pssVtbl));
  69 }
  70
  71 /* These are documented in MSDN, e.g.
  72  * http://msdn.microsoft.com/library/en-us/stg/stg/property_set_header.asp
  73  * http://msdn.microsoft.com/library/library/en-us/stg/stg/section.asp
  74  * but they don't seem to be in any header file.
  75  */
  76 #define PROPSETHDR_BYTEORDER_MAGIC      0xfffe
  77 #define PROPSETHDR_OSVER_KIND_WIN16     0
  78 #define PROPSETHDR_OSVER_KIND_MAC       1
  79 #define PROPSETHDR_OSVER_KIND_WIN32     2
  80
  81 #define CP_UNICODE 1200
  82
  83 #define MAX_VERSION_0_PROP_NAME_LENGTH 256
  84
  85 #define CFTAG_WINDOWS   (-1L)
  86 #define CFTAG_MACINTOSH (-2L)
  87 #define CFTAG_FMTID     (-3L)
  88 #define CFTAG_NODATA      0L
  89
  90 /* The format version (and what it implies) is described here:
  91  * http://msdn.microsoft.com/library/en-us/stg/stg/format_version.asp
  92  */
  93 typedef struct tagPROPERTYSETHEADER
  94 {
  95     WORD  wByteOrder; /* always 0xfffe */
  96     WORD  wFormat;    /* can be zero or one */
  97     DWORD dwOSVer;    /* OS version of originating system */
  98     CLSID clsid;      /* application CLSID */
  99     DWORD reserved;   /* always 1 */
 100 } PROPERTYSETHEADER;
 101
 102 typedef struct tagFORMATIDOFFSET
 103 {
 104     FMTID fmtid;
 105     DWORD dwOffset; /* from beginning of stream */
 106 } FORMATIDOFFSET;
 107
 108 typedef struct tagPROPERTYSECTIONHEADER
 109 {
 110     DWORD cbSection;
 111     DWORD cProperties;
 112 } PROPERTYSECTIONHEADER;
 113
 114 typedef struct tagPROPERTYIDOFFSET
 115 {
 116     DWORD propid;
 117     DWORD dwOffset; /* from beginning of section */
 118 } PROPERTYIDOFFSET;
 119
 120 typedef struct tagPropertyStorage_impl PropertyStorage_impl;
 121
 122 /* Initializes the property storage from the stream (and undoes any uncommitted
 123  * changes in the process.)  Returns an error if there is an error reading or
 124  * if the stream format doesn't match what's expected.
 125  */
 126 static HRESULT PropertyStorage_ReadFromStream(PropertyStorage_impl *);
 127
 128 static HRESULT PropertyStorage_WriteToStream(PropertyStorage_impl *);
 129
 130 /* Creates the dictionaries used by the property storage.  If successful, all
 131  * the dictionaries have been created.  If failed, none has been.  (This makes
 132  * it a bit easier to deal with destroying them.)
 133  */
 134 static HRESULT PropertyStorage_CreateDictionaries(PropertyStorage_impl *);
 135
 136 static void PropertyStorage_DestroyDictionaries(PropertyStorage_impl *);
 137
 138 /* Copies from propvar to prop.  If propvar's type is VT_LPSTR, copies the
 139  * string using PropertyStorage_StringCopy.
 140  */
 141 static HRESULT PropertyStorage_PropVariantCopy(PROPVARIANT *prop,
 142  const PROPVARIANT *propvar, LCID targetCP, LCID srcCP);
 143
 144 /* Copies the string src, which is encoded using code page srcCP, and returns
 145  * it in *dst, in the code page specified by targetCP.  The returned string is
 146  * allocated using CoTaskMemAlloc.
 147  * If srcCP is CP_UNICODE, src is in fact an LPCWSTR.  Similarly, if targetCP
 148  * is CP_UNICODE, the returned string is in fact an LPWSTR.
 149  * Returns S_OK on success, something else on failure.
 150  */
 151 static HRESULT PropertyStorage_StringCopy(LPCSTR src, LCID srcCP, LPSTR *dst,
 152  LCID targetCP);
 153
 154 static const IPropertyStorageVtbl IPropertyStorage_Vtbl;
 155 static const IEnumSTATPROPSETSTGVtbl IEnumSTATPROPSETSTG_Vtbl;
 156 static const IEnumSTATPROPSTGVtbl IEnumSTATPROPSTG_Vtbl;
 157 static HRESULT create_EnumSTATPROPSETSTG(StorageImpl *, IEnumSTATPROPSETSTG**);
 158 static HRESULT create_EnumSTATPROPSTG(PropertyStorage_impl *, IEnumSTATPROPSTG**);
 159
 160 /***********************************************************************
 161  * Implementation of IPropertyStorage
 162  */
 163 struct tagPropertyStorage_impl
 164 {
 165     const IPropertyStorageVtbl *vtbl;
 166     LONG ref;
 167     CRITICAL_SECTION cs;
 168     IStream *stm;
 169     BOOL  dirty;
 170     FMTID fmtid;
 171     CLSID clsid;
 172     WORD  format;
 173     DWORD originatorOS;
 174     DWORD grfFlags;
 175     DWORD grfMode;
 176     UINT  codePage;
 177     LCID  locale;
 178     PROPID highestProp;
 179     struct dictionary *name_to_propid;
 180     struct dictionary *propid_to_name;
 181     struct dictionary *propid_to_prop;
 182 };
 183
 184 /************************************************************************
 185  * IPropertyStorage_fnQueryInterface (IPropertyStorage)
 186  */
 187 static HRESULT WINAPI IPropertyStorage_fnQueryInterface(
 188     IPropertyStorage *iface,
 189     REFIID riid,
 190     void** ppvObject)
 191 {
 192     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 193
 194     if ( (This==0) || (ppvObject==0) )
 195         return E_INVALIDARG;
 196
 197     *ppvObject = 0;
 198
 199     if (IsEqualGUID(&IID_IUnknown, riid) ||
 200         IsEqualGUID(&IID_IPropertyStorage, riid))
 201     {
 202         IPropertyStorage_AddRef(iface);
 203         *ppvObject = (IPropertyStorage*)iface;
 204         return S_OK;
 205     }
 206
 207     return E_NOINTERFACE;
 208 }
 209
 210 /************************************************************************
 211  * IPropertyStorage_fnAddRef (IPropertyStorage)
 212  */
 213 static ULONG WINAPI IPropertyStorage_fnAddRef(
 214     IPropertyStorage *iface)
 215 {
 216     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 217     return InterlockedIncrement(&This->ref);
 218 }
 219
 220 /************************************************************************
 221  * IPropertyStorage_fnRelease (IPropertyStorage)
 222  */
 223 static ULONG WINAPI IPropertyStorage_fnRelease(
 224     IPropertyStorage *iface)
 225 {
 226     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 227     ULONG ref;
 228
 229     ref = InterlockedDecrement(&This->ref);
 230     if (ref == 0)
 231     {
 232         TRACE("Destroying %p\n", This);
 233         if (This->dirty)
 234             IPropertyStorage_Commit(iface, STGC_DEFAULT);
 235         IStream_Release(This->stm);
 236         DeleteCriticalSection(&This->cs);
 237         PropertyStorage_DestroyDictionaries(This);
 238         HeapFree(GetProcessHeap(), 0, This);
 239     }
 240     return ref;
 241 }
 242
 243 static PROPVARIANT *PropertyStorage_FindProperty(PropertyStorage_impl *This,
 244  DWORD propid)
 245 {
 246     PROPVARIANT *ret = NULL;
 247
 248     dictionary_find(This->propid_to_prop, (void *)propid, (void **)&ret);
 249     TRACE("returning %p\n", ret);
 250     return ret;
 251 }
 252
 253 /* Returns NULL if name is NULL. */
 254 static PROPVARIANT *PropertyStorage_FindPropertyByName(
 255  PropertyStorage_impl *This, LPCWSTR name)
 256 {
 257     PROPVARIANT *ret = NULL;
 258     PROPID propid;
 259
 260     if (!name)
 261         return NULL;
 262     if (This->codePage == CP_UNICODE)
 263     {
 264         if (dictionary_find(This->name_to_propid, name, (void **)&propid))
 265             ret = PropertyStorage_FindProperty(This, (PROPID)propid);
 266     }
 267     else
 268     {
 269         LPSTR ansiName;
 270         HRESULT hr = PropertyStorage_StringCopy((LPCSTR)name, CP_UNICODE,
 271          &ansiName, This->codePage);
 272
 273         if (SUCCEEDED(hr))
 274         {
 275             if (dictionary_find(This->name_to_propid, ansiName,
 276              (void **)&propid))
 277                 ret = PropertyStorage_FindProperty(This, (PROPID)propid);
 278             CoTaskMemFree(ansiName);
 279         }
 280     }
 281     TRACE("returning %p\n", ret);
 282     return ret;
 283 }
 284
 285 static LPWSTR PropertyStorage_FindPropertyNameById(PropertyStorage_impl *This,
 286  DWORD propid)
 287 {
 288     LPWSTR ret = NULL;
 289
 290     dictionary_find(This->propid_to_name, (void *)propid, (void **)&ret);
 291     TRACE("returning %p\n", ret);
 292     return ret;
 293 }
 294
 295 /************************************************************************
 296  * IPropertyStorage_fnReadMultiple (IPropertyStorage)
 297  */
 298 static HRESULT WINAPI IPropertyStorage_fnReadMultiple(
 299     IPropertyStorage* iface,
 300     ULONG cpspec,
 301     const PROPSPEC rgpspec[],
 302     PROPVARIANT rgpropvar[])
 303 {
 304     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 305     HRESULT hr = S_OK;
 306     ULONG i;
 307
 308     TRACE("(%p, %ld, %p, %p)\n", iface, cpspec, rgpspec, rgpropvar);
 309
 310     if (!cpspec)
 311         return S_FALSE;
 312     if (!rgpspec || !rgpropvar)
 313         return E_INVALIDARG;
 314     EnterCriticalSection(&This->cs);
 315     for (i = 0; i < cpspec; i++)
 316     {
 317         PropVariantInit(&rgpropvar[i]);
 318         if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
 319         {
 320             PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
 321              rgpspec[i].u.lpwstr);
 322
 323             if (prop)
 324                 PropertyStorage_PropVariantCopy(&rgpropvar[i], prop, GetACP(),
 325                  This->codePage);
 326         }
 327         else
 328         {
 329             switch (rgpspec[i].u.propid)
 330             {
 331                 case PID_CODEPAGE:
 332                     rgpropvar[i].vt = VT_I2;
 333                     rgpropvar[i].u.iVal = This->codePage;
 334                     break;
 335                 case PID_LOCALE:
 336                     rgpropvar[i].vt = VT_I4;
 337                     rgpropvar[i].u.lVal = This->locale;
 338                     break;
 339                 default:
 340                 {
 341                     PROPVARIANT *prop = PropertyStorage_FindProperty(This,
 342                      rgpspec[i].u.propid);
 343
 344                     if (prop)
 345                         PropertyStorage_PropVariantCopy(&rgpropvar[i], prop,
 346                          GetACP(), This->codePage);
 347                     else
 348                         hr = S_FALSE;
 349                 }
 350             }
 351         }
 352     }
 353     LeaveCriticalSection(&This->cs);
 354     return hr;
 355 }
 356
 357 static HRESULT PropertyStorage_StringCopy(LPCSTR src, LCID srcCP, LPSTR *dst,
 358  LCID dstCP)
 359 {
 360     HRESULT hr = S_OK;
 361     int len;
 362
 363     TRACE("%s, %p, %ld, %ld\n",
 364      srcCP == CP_UNICODE ? debugstr_w((LPCWSTR)src) : debugstr_a(src), dst,
 365      dstCP, srcCP);
 366     assert(src);
 367     assert(dst);
 368     *dst = NULL;
 369     if (dstCP == srcCP)
 370     {
 371         size_t len;
 372
 373         if (dstCP == CP_UNICODE)
 374             len = (strlenW((LPCWSTR)src) + 1) * sizeof(WCHAR);
 375         else
 376             len = strlen(src) + 1;
 377         *dst = CoTaskMemAlloc(len * sizeof(WCHAR));
 378         if (!*dst)
 379             hr = STG_E_INSUFFICIENTMEMORY;
 380         else
 381             memcpy(*dst, src, len);
 382     }
 383     else
 384     {
 385         if (dstCP == CP_UNICODE)
 386         {
 387             len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
 388             *dst = CoTaskMemAlloc(len * sizeof(WCHAR));
 389             if (!*dst)
 390                 hr = STG_E_INSUFFICIENTMEMORY;
 391             else
 392                 MultiByteToWideChar(srcCP, 0, src, -1, (LPWSTR)*dst, len);
 393         }
 394         else
 395         {
 396             LPWSTR wideStr;
 397
 398             if (srcCP == CP_UNICODE)
 399                 wideStr = (LPWSTR)src;
 400             else
 401             {
 402                 len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
 403                 wideStr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 404                 if (wideStr)
 405                     MultiByteToWideChar(srcCP, 0, src, -1, wideStr, len);
 406                 else
 407                     hr = STG_E_INSUFFICIENTMEMORY;
 408             }
 409             if (SUCCEEDED(hr))
 410             {
 411                 len = WideCharToMultiByte(dstCP, 0, wideStr, -1, NULL, 0,
 412                  NULL, NULL);
 413                 *dst = CoTaskMemAlloc(len);
 414                 if (!*dst)
 415                     hr = STG_E_INSUFFICIENTMEMORY;
 416                 else
 417                 {
 418                     BOOL defCharUsed = FALSE;
 419
 420                     if (WideCharToMultiByte(dstCP, 0, wideStr, -1, *dst, len,
 421                      NULL, &defCharUsed) == 0 || defCharUsed)
 422                     {
 423                         CoTaskMemFree(*dst);
 424                         *dst = NULL;
 425                         hr = HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION);
 426                     }
 427                 }
 428             }
 429             if (wideStr != (LPWSTR)src)
 430                 HeapFree(GetProcessHeap(), 0, wideStr);
 431         }
 432     }
 433     TRACE("returning 0x%08lx (%s)\n", hr,
 434      dstCP == CP_UNICODE ? debugstr_w((LPCWSTR)*dst) : debugstr_a(*dst));
 435     return hr;
 436 }
 437
 438 static HRESULT PropertyStorage_PropVariantCopy(PROPVARIANT *prop,
 439  const PROPVARIANT *propvar, LCID targetCP, LCID srcCP)
 440 {
 441     HRESULT hr = S_OK;
 442
 443     assert(prop);
 444     assert(propvar);
 445     if (propvar->vt == VT_LPSTR)
 446     {
 447         hr = PropertyStorage_StringCopy(propvar->u.pszVal, srcCP,
 448          &prop->u.pszVal, targetCP);
 449         if (SUCCEEDED(hr))
 450             prop->vt = VT_LPSTR;
 451     }
 452     else
 453         PropVariantCopy(prop, propvar);
 454     return hr;
 455 }
 456
 457 /* Stores the property with id propid and value propvar into this property
 458  * storage.  lcid is ignored if propvar's type is not VT_LPSTR.  If propvar's
 459  * type is VT_LPSTR, converts the string using lcid as the source code page
 460  * and This->codePage as the target code page before storing.
 461  * As a side effect, may change This->format to 1 if the type of propvar is
 462  * a version 1-only property.
 463  */
 464 static HRESULT PropertyStorage_StorePropWithId(PropertyStorage_impl *This,
 465  PROPID propid, const PROPVARIANT *propvar, LCID lcid)
 466 {
 467     HRESULT hr = S_OK;
 468     PROPVARIANT *prop = PropertyStorage_FindProperty(This, propid);
 469
 470     assert(propvar);
 471     if (propvar->vt & VT_BYREF || propvar->vt & VT_ARRAY)
 472         This->format = 1;
 473     switch (propvar->vt)
 474     {
 475     case VT_DECIMAL:
 476     case VT_I1:
 477     case VT_INT:
 478     case VT_UINT:
 479     case VT_VECTOR|VT_I1:
 480         This->format = 1;
 481     }
 482     TRACE("Setting 0x%08lx to type %d\n", propid, propvar->vt);
 483     if (prop)
 484     {
 485         PropVariantClear(prop);
 486         hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage,
 487          lcid);
 488     }
 489     else
 490     {
 491         prop = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 492          sizeof(PROPVARIANT));
 493         if (prop)
 494         {
 495             hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage,
 496              lcid);
 497             if (SUCCEEDED(hr))
 498             {
 499                 dictionary_insert(This->propid_to_prop, (void *)propid, prop);
 500                 if (propid > This->highestProp)
 501                     This->highestProp = propid;
 502             }
 503             else
 504                 HeapFree(GetProcessHeap(), 0, prop);
 505         }
 506         else
 507             hr = STG_E_INSUFFICIENTMEMORY;
 508     }
 509     return hr;
 510 }
 511
 512 /* Adds the name srcName to the name dictionaries, mapped to property ID id.
 513  * srcName is encoded in code page cp, and is converted to This->codePage.
 514  * If cp is CP_UNICODE, srcName is actually a unicode string.
 515  * As a side effect, may change This->format to 1 if srcName is too long for
 516  * a version 0 property storage.
 517  * Doesn't validate id.
 518  */
 519 static HRESULT PropertyStorage_StoreNameWithId(PropertyStorage_impl *This,
 520  LPCSTR srcName, LCID cp, PROPID id)
 521 {
 522     LPSTR name;
 523     HRESULT hr;
 524
 525     assert(srcName);
 526
 527     hr = PropertyStorage_StringCopy((LPCSTR)srcName, cp, &name, This->codePage);
 528     if (SUCCEEDED(hr))
 529     {
 530         if (This->codePage == CP_UNICODE)
 531         {
 532             if (lstrlenW((LPWSTR)name) >= MAX_VERSION_0_PROP_NAME_LENGTH)
 533                 This->format = 1;
 534         }
 535         else
 536         {
 537             if (strlen(name) >= MAX_VERSION_0_PROP_NAME_LENGTH)
 538                 This->format = 1;
 539         }
 540         TRACE("Adding prop name %s, propid %ld\n",
 541          This->codePage == CP_UNICODE ? debugstr_w((LPCWSTR)name) :
 542          debugstr_a(name), id);
 543         dictionary_insert(This->name_to_propid, name, (void *)id);
 544         dictionary_insert(This->propid_to_name, (void *)id, name);
 545     }
 546     return hr;
 547 }
 548
 549 /************************************************************************
 550  * IPropertyStorage_fnWriteMultiple (IPropertyStorage)
 551  */
 552 static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
 553     IPropertyStorage* iface,
 554     ULONG cpspec,
 555     const PROPSPEC rgpspec[],
 556     const PROPVARIANT rgpropvar[],
 557     PROPID propidNameFirst)
 558 {
 559     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 560     HRESULT hr = S_OK;
 561     ULONG i;
 562
 563     TRACE("(%p, %ld, %p, %p)\n", iface, cpspec, rgpspec, rgpropvar);
 564
 565     if (cpspec && (!rgpspec || !rgpropvar))
 566         return E_INVALIDARG;
 567     if (!(This->grfMode & STGM_READWRITE))
 568         return STG_E_ACCESSDENIED;
 569     EnterCriticalSection(&This->cs);
 570     This->dirty = TRUE;
 571     This->originatorOS = (DWORD)MAKELONG(LOWORD(GetVersion()),
 572      PROPSETHDR_OSVER_KIND_WIN32) ;
 573     for (i = 0; i < cpspec; i++)
 574     {
 575         if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
 576         {
 577             PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
 578              rgpspec[i].u.lpwstr);
 579
 580             if (prop)
 581                 PropVariantCopy(prop, &rgpropvar[i]);
 582             else
 583             {
 584                 /* Note that I don't do the special cases here that I do below,
 585                  * because naming the special PIDs isn't supported.
 586                  */
 587                 if (propidNameFirst < PID_FIRST_USABLE ||
 588                  propidNameFirst >= PID_MIN_READONLY)
 589                     hr = STG_E_INVALIDPARAMETER;
 590                 else
 591                 {
 592                     PROPID nextId = max(propidNameFirst, This->highestProp + 1);
 593
 594                     hr = PropertyStorage_StoreNameWithId(This,
 595                      (LPCSTR)rgpspec[i].u.lpwstr, CP_UNICODE, nextId);
 596                     if (SUCCEEDED(hr))
 597                         hr = PropertyStorage_StorePropWithId(This, nextId,
 598                          &rgpropvar[i], GetACP());
 599                 }
 600             }
 601         }
 602         else
 603         {
 604             switch (rgpspec[i].u.propid)
 605             {
 606             case PID_DICTIONARY:
 607                 /* Can't set the dictionary */
 608                 hr = STG_E_INVALIDPARAMETER;
 609                 break;
 610             case PID_CODEPAGE:
 611                 /* Can only set the code page if nothing else has been set */
 612                 if (dictionary_num_entries(This->propid_to_prop) == 0 &&
 613                  rgpropvar[i].vt == VT_I2)
 614                 {
 615                     This->codePage = rgpropvar[i].u.iVal;
 616                     if (This->codePage == CP_UNICODE)
 617                         This->grfFlags &= ~PROPSETFLAG_ANSI;
 618                     else
 619                         This->grfFlags |= PROPSETFLAG_ANSI;
 620                 }
 621                 else
 622                     hr = STG_E_INVALIDPARAMETER;
 623                 break;
 624             case PID_LOCALE:
 625                 /* Can only set the locale if nothing else has been set */
 626                 if (dictionary_num_entries(This->propid_to_prop) == 0 &&
 627                  rgpropvar[i].vt == VT_I4)
 628                     This->locale = rgpropvar[i].u.lVal;
 629                 else
 630                     hr = STG_E_INVALIDPARAMETER;
 631                 break;
 632             case PID_ILLEGAL:
 633                 /* silently ignore like MSDN says */
 634                 break;
 635             default:
 636                 if (rgpspec[i].u.propid >= PID_MIN_READONLY)
 637                     hr = STG_E_INVALIDPARAMETER;
 638                 else
 639                     hr = PropertyStorage_StorePropWithId(This,
 640                      rgpspec[i].u.propid, &rgpropvar[i], GetACP());
 641             }
 642         }
 643     }
 644     if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
 645         IPropertyStorage_Commit(iface, STGC_DEFAULT);
 646     LeaveCriticalSection(&This->cs);
 647     return hr;
 648 }
 649
 650 /************************************************************************
 651  * IPropertyStorage_fnDeleteMultiple (IPropertyStorage)
 652  */
 653 static HRESULT WINAPI IPropertyStorage_fnDeleteMultiple(
 654     IPropertyStorage* iface,
 655     ULONG cpspec,
 656     const PROPSPEC rgpspec[])
 657 {
 658     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 659     ULONG i;
 660     HRESULT hr;
 661
 662     TRACE("(%p, %ld, %p)\n", iface, cpspec, rgpspec);
 663
 664     if (cpspec && !rgpspec)
 665         return E_INVALIDARG;
 666     if (!(This->grfMode & STGM_READWRITE))
 667         return STG_E_ACCESSDENIED;
 668     hr = S_OK;
 669     EnterCriticalSection(&This->cs);
 670     This->dirty = TRUE;
 671     for (i = 0; i < cpspec; i++)
 672     {
 673         if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
 674         {
 675             PROPID propid;
 676
 677             if (dictionary_find(This->name_to_propid,
 678              (void *)rgpspec[i].u.lpwstr, (void **)&propid))
 679                 dictionary_remove(This->propid_to_prop, (void *)propid);
 680         }
 681         else
 682         {
 683             if (rgpspec[i].u.propid >= PID_FIRST_USABLE &&
 684              rgpspec[i].u.propid < PID_MIN_READONLY)
 685                 dictionary_remove(This->propid_to_prop,
 686                  (void *)rgpspec[i].u.propid);
 687             else
 688                 hr = STG_E_INVALIDPARAMETER;
 689         }
 690     }
 691     if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
 692         IPropertyStorage_Commit(iface, STGC_DEFAULT);
 693     LeaveCriticalSection(&This->cs);
 694     return hr;
 695 }
 696
 697 /************************************************************************
 698  * IPropertyStorage_fnReadPropertyNames (IPropertyStorage)
 699  */
 700 static HRESULT WINAPI IPropertyStorage_fnReadPropertyNames(
 701     IPropertyStorage* iface,
 702     ULONG cpropid,
 703     const PROPID rgpropid[],
 704     LPOLESTR rglpwstrName[])
 705 {
 706     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 707     ULONG i;
 708     HRESULT hr = S_FALSE;
 709
 710     TRACE("(%p, %ld, %p, %p)\n", iface, cpropid, rgpropid, rglpwstrName);
 711
 712     if (cpropid && (!rgpropid || !rglpwstrName))
 713         return E_INVALIDARG;
 714     EnterCriticalSection(&This->cs);
 715     for (i = 0; i < cpropid && SUCCEEDED(hr); i++)
 716     {
 717         LPWSTR name = PropertyStorage_FindPropertyNameById(This, rgpropid[i]);
 718
 719         if (name)
 720         {
 721             size_t len = lstrlenW(name);
 722
 723             hr = S_OK;
 724             rglpwstrName[i] = CoTaskMemAlloc((len + 1) * sizeof(WCHAR));
 725             if (rglpwstrName)
 726                 memcpy(rglpwstrName, name, (len + 1) * sizeof(WCHAR));
 727             else
 728                 hr = STG_E_INSUFFICIENTMEMORY;
 729         }
 730         else
 731             rglpwstrName[i] = NULL;
 732     }
 733     LeaveCriticalSection(&This->cs);
 734     return hr;
 735 }
 736
 737 /************************************************************************
 738  * IPropertyStorage_fnWritePropertyNames (IPropertyStorage)
 739  */
 740 static HRESULT WINAPI IPropertyStorage_fnWritePropertyNames(
 741     IPropertyStorage* iface,
 742     ULONG cpropid,
 743     const PROPID rgpropid[],
 744     const LPOLESTR rglpwstrName[])
 745 {
 746     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 747     ULONG i;
 748     HRESULT hr;
 749
 750     TRACE("(%p, %ld, %p, %p)\n", iface, cpropid, rgpropid, rglpwstrName);
 751
 752     if (cpropid && (!rgpropid || !rglpwstrName))
 753         return E_INVALIDARG;
 754     if (!(This->grfMode & STGM_READWRITE))
 755         return STG_E_ACCESSDENIED;
 756     hr = S_OK;
 757     EnterCriticalSection(&This->cs);
 758     This->dirty = TRUE;
 759     for (i = 0; SUCCEEDED(hr) && i < cpropid; i++)
 760     {
 761         if (rgpropid[i] != PID_ILLEGAL)
 762             hr = PropertyStorage_StoreNameWithId(This, (LPCSTR)rglpwstrName[i],
 763              CP_UNICODE, rgpropid[i]);
 764     }
 765     if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
 766         IPropertyStorage_Commit(iface, STGC_DEFAULT);
 767     LeaveCriticalSection(&This->cs);
 768     return hr;
 769 }
 770
 771 /************************************************************************
 772  * IPropertyStorage_fnDeletePropertyNames (IPropertyStorage)
 773  */
 774 static HRESULT WINAPI IPropertyStorage_fnDeletePropertyNames(
 775     IPropertyStorage* iface,
 776     ULONG cpropid,
 777     const PROPID rgpropid[])
 778 {
 779     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 780     ULONG i;
 781     HRESULT hr;
 782
 783     TRACE("(%p, %ld, %p)\n", iface, cpropid, rgpropid);
 784
 785     if (cpropid && !rgpropid)
 786         return E_INVALIDARG;
 787     if (!(This->grfMode & STGM_READWRITE))
 788         return STG_E_ACCESSDENIED;
 789     hr = S_OK;
 790     EnterCriticalSection(&This->cs);
 791     This->dirty = TRUE;
 792     for (i = 0; i < cpropid; i++)
 793     {
 794         LPWSTR name = NULL;
 795
 796         if (dictionary_find(This->propid_to_name, (void *)rgpropid[i],
 797          (void **)&name))
 798         {
 799             dictionary_remove(This->propid_to_name, (void *)rgpropid[i]);
 800             dictionary_remove(This->name_to_propid, name);
 801         }
 802     }
 803     if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
 804         IPropertyStorage_Commit(iface, STGC_DEFAULT);
 805     LeaveCriticalSection(&This->cs);
 806     return hr;
 807 }
 808
 809 /************************************************************************
 810  * IPropertyStorage_fnCommit (IPropertyStorage)
 811  */
 812 static HRESULT WINAPI IPropertyStorage_fnCommit(
 813     IPropertyStorage* iface,
 814     DWORD grfCommitFlags)
 815 {
 816     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 817     HRESULT hr;
 818
 819     TRACE("(%p, 0x%08lx)\n", iface, grfCommitFlags);
 820
 821     if (!(This->grfMode & STGM_READWRITE))
 822         return STG_E_ACCESSDENIED;
 823     EnterCriticalSection(&This->cs);
 824     if (This->dirty)
 825         hr = PropertyStorage_WriteToStream(This);
 826     else
 827         hr = S_OK;
 828     LeaveCriticalSection(&This->cs);
 829     return hr;
 830 }
 831
 832 /************************************************************************
 833  * IPropertyStorage_fnRevert (IPropertyStorage)
 834  */
 835 static HRESULT WINAPI IPropertyStorage_fnRevert(
 836     IPropertyStorage* iface)
 837 {
 838     HRESULT hr;
 839     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 840
 841     TRACE("%p\n", iface);
 842
 843     EnterCriticalSection(&This->cs);
 844     if (This->dirty)
 845     {
 846         PropertyStorage_DestroyDictionaries(This);
 847         hr = PropertyStorage_CreateDictionaries(This);
 848         if (SUCCEEDED(hr))
 849             hr = PropertyStorage_ReadFromStream(This);
 850     }
 851     else
 852         hr = S_OK;
 853     LeaveCriticalSection(&This->cs);
 854     return hr;
 855 }
 856
 857 /************************************************************************
 858  * IPropertyStorage_fnEnum (IPropertyStorage)
 859  */
 860 static HRESULT WINAPI IPropertyStorage_fnEnum(
 861     IPropertyStorage* iface,
 862     IEnumSTATPROPSTG** ppenum)
 863 {
 864     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 865     return create_EnumSTATPROPSTG(This, ppenum);
 866 }
 867
 868 /************************************************************************
 869  * IPropertyStorage_fnSetTimes (IPropertyStorage)
 870  */
 871 static HRESULT WINAPI IPropertyStorage_fnSetTimes(
 872     IPropertyStorage* iface,
 873     const FILETIME* pctime,
 874     const FILETIME* patime,
 875     const FILETIME* pmtime)
 876 {
 877     FIXME("\n");
 878     return E_NOTIMPL;
 879 }
 880
 881 /************************************************************************
 882  * IPropertyStorage_fnSetClass (IPropertyStorage)
 883  */
 884 static HRESULT WINAPI IPropertyStorage_fnSetClass(
 885     IPropertyStorage* iface,
 886     REFCLSID clsid)
 887 {
 888     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 889
 890     TRACE("%p, %s\n", iface, debugstr_guid(clsid));
 891
 892     if (!clsid)
 893         return E_INVALIDARG;
 894     if (!(This->grfMode & STGM_READWRITE))
 895         return STG_E_ACCESSDENIED;
 896     memcpy(&This->clsid, clsid, sizeof(This->clsid));
 897     This->dirty = TRUE;
 898     if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
 899         IPropertyStorage_Commit(iface, STGC_DEFAULT);
 900     return S_OK;
 901 }
 902
 903 /************************************************************************
 904  * IPropertyStorage_fnStat (IPropertyStorage)
 905  */
 906 static HRESULT WINAPI IPropertyStorage_fnStat(
 907     IPropertyStorage* iface,
 908     STATPROPSETSTG* statpsstg)
 909 {
 910     PropertyStorage_impl *This = (PropertyStorage_impl *)iface;
 911     STATSTG stat;
 912     HRESULT hr;
 913
 914     TRACE("%p, %p\n", iface, statpsstg);
 915
 916     if (!statpsstg)
 917         return E_INVALIDARG;
 918
 919     hr = IStream_Stat(This->stm, &stat, STATFLAG_NONAME);
 920     if (SUCCEEDED(hr))
 921     {
 922         memcpy(&statpsstg->fmtid, &This->fmtid, sizeof(statpsstg->fmtid));
 923         memcpy(&statpsstg->clsid, &This->clsid, sizeof(statpsstg->clsid));
 924         statpsstg->grfFlags = This->grfFlags;
 925         memcpy(&statpsstg->mtime, &stat.mtime, sizeof(statpsstg->mtime));
 926         memcpy(&statpsstg->ctime, &stat.ctime, sizeof(statpsstg->ctime));
 927         memcpy(&statpsstg->atime, &stat.atime, sizeof(statpsstg->atime));
 928         statpsstg->dwOSVersion = This->originatorOS;
 929     }
 930     return hr;
 931 }
 932
 933 static int PropertyStorage_PropNameCompare(const void *a, const void *b,
 934  void *extra)
 935 {
 936     PropertyStorage_impl *This = (PropertyStorage_impl *)extra;
 937
 938     if (This->codePage == CP_UNICODE)
 939     {
 940         TRACE("(%s, %s)\n", debugstr_w(a), debugstr_w(b));
 941         if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
 942             return lstrcmpW((LPCWSTR)a, (LPCWSTR)b);
 943         else
 944             return lstrcmpiW((LPCWSTR)a, (LPCWSTR)b);
 945     }
 946     else
 947     {
 948         TRACE("(%s, %s)\n", debugstr_a(a), debugstr_a(b));
 949         if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
 950             return lstrcmpA((LPCSTR)a, (LPCSTR)b);
 951         else
 952             return lstrcmpiA((LPCSTR)a, (LPCSTR)b);
 953     }
 954 }
 955
 956 static void PropertyStorage_PropNameDestroy(void *k, void *d, void *extra)
 957 {
 958     CoTaskMemFree(k);
 959 }
 960
 961 static int PropertyStorage_PropCompare(const void *a, const void *b,
 962  void *extra)
 963 {
 964     TRACE("(%ld, %ld)\n", (PROPID)a, (PROPID)b);
 965     return (PROPID)a - (PROPID)b;
 966 }
 967
 968 static void PropertyStorage_PropertyDestroy(void *k, void *d, void *extra)
 969 {
 970     PropVariantClear((PROPVARIANT *)d);
 971     HeapFree(GetProcessHeap(), 0, d);
 972 }
 973
 974 #ifdef WORDS_BIGENDIAN
 975 /* Swaps each character in str to or from little endian; assumes the conversion
 976  * is symmetric, that is, that le16toh is equivalent to htole16.
 977  */
 978 static void PropertyStorage_ByteSwapString(LPWSTR str, size_t len)
 979 {
 980     DWORD i;
 981
 982     /* Swap characters to host order.
 983      * FIXME: alignment?
 984      */
 985     for (i = 0; i < len; i++)
 986         str[i] = le16toh(str[i]);
 987 }
 988 #else
 989 #define PropertyStorage_ByteSwapString(s, l)
 990 #endif
 991
 992 /* Reads the dictionary from the memory buffer beginning at ptr.  Interprets
 993  * the entries according to the values of This->codePage and This->locale.
 994  * FIXME: there isn't any checking whether the read property extends past the
 995  * end of the buffer.
 996  */
 997 static HRESULT PropertyStorage_ReadDictionary(PropertyStorage_impl *This,
 998  BYTE *ptr)
 999 {
1000     DWORD numEntries, i;
1001     HRESULT hr = S_OK;
1002
1003     assert(This->name_to_propid);
1004     assert(This->propid_to_name);
1005
1006     StorageUtl_ReadDWord(ptr, 0, &numEntries);
1007     TRACE("Reading %ld entries:\n", numEntries);
1008     ptr += sizeof(DWORD);
1009     for (i = 0; SUCCEEDED(hr) && i < numEntries; i++)
1010     {
1011         PROPID propid;
1012         DWORD cbEntry;
1013
1014         StorageUtl_ReadDWord(ptr, 0, &propid);
1015         ptr += sizeof(PROPID);
1016         StorageUtl_ReadDWord(ptr, 0, &cbEntry);
1017         ptr += sizeof(DWORD);
1018         TRACE("Reading entry with ID 0x%08lx, %ld bytes\n", propid, cbEntry);
1019         /* Make sure the source string is NULL-terminated */
1020         if (This->codePage != CP_UNICODE)
1021             ptr[cbEntry - 1] = '\0';
1022         else
1023             *((LPWSTR)ptr + cbEntry / sizeof(WCHAR)) = '\0';
1024         hr = PropertyStorage_StoreNameWithId(This, (char*)ptr, This->codePage, propid);
1025         if (This->codePage == CP_UNICODE)
1026         {
1027             /* Unicode entries are padded to DWORD boundaries */
1028             if (cbEntry % sizeof(DWORD))
1029                 ptr += sizeof(DWORD) - (cbEntry % sizeof(DWORD));
1030         }
1031         ptr += sizeof(DWORD) + cbEntry;
1032     }
1033     return hr;
1034 }
1035
1036 /* FIXME: there isn't any checking whether the read property extends past the
1037  * end of the buffer.
1038  */
1039 static HRESULT PropertyStorage_ReadProperty(PropertyStorage_impl *This,
1040  PROPVARIANT *prop, const BYTE *data)
1041 {
1042     HRESULT hr = S_OK;
1043
1044     assert(prop);
1045     assert(data);
1046     StorageUtl_ReadDWord(data, 0, (DWORD *)&prop->vt);
1047     data += sizeof(DWORD);
1048     switch (prop->vt)
1049     {
1050     case VT_EMPTY:
1051     case VT_NULL:
1052         break;
1053     case VT_I1:
1054         prop->u.cVal = *(const char *)data;
1055         TRACE("Read char 0x%x ('%c')\n", prop->u.cVal, prop->u.cVal);
1056         break;
1057     case VT_UI1:
1058         prop->u.bVal = *(const UCHAR *)data;
1059         TRACE("Read byte 0x%x\n", prop->u.bVal);
1060         break;
1061     case VT_I2:
1062         StorageUtl_ReadWord(data, 0, (WORD*)&prop->u.iVal);
1063         TRACE("Read short %d\n", prop->u.iVal);
1064         break;
1065     case VT_UI2:
1066         StorageUtl_ReadWord(data, 0, &prop->u.uiVal);
1067         TRACE("Read ushort %d\n", prop->u.uiVal);
1068         break;
1069     case VT_INT:
1070     case VT_I4:
1071         StorageUtl_ReadDWord(data, 0, (DWORD*)&prop->u.lVal);
1072         TRACE("Read long %ld\n", prop->u.lVal);
1073         break;
1074     case VT_UINT:
1075     case VT_UI4:
1076         StorageUtl_ReadDWord(data, 0, &prop->u.ulVal);
1077         TRACE("Read ulong %ld\n", prop->u.ulVal);
1078         break;
1079     case VT_LPSTR:
1080     {
1081         DWORD count;
1082
1083         StorageUtl_ReadDWord(data, 0, &count);
1084         if (This->codePage == CP_UNICODE && count / 2)
1085         {
1086             WARN("Unicode string has odd number of bytes\n");
1087             hr = STG_E_INVALIDHEADER;
1088         }
1089         else
1090         {
1091             prop->u.pszVal = CoTaskMemAlloc(count);
1092             if (prop->u.pszVal)
1093             {
1094                 memcpy(prop->u.pszVal, data + sizeof(DWORD), count);
1095                 /* This is stored in the code page specified in This->codePage.
1096                  * Don't convert it, the caller will just store it as-is.
1097                  */
1098                 if (This->codePage == CP_UNICODE)
1099                 {
1100                     /* Make sure it's NULL-terminated */
1101                     prop->u.pszVal[count / sizeof(WCHAR) - 1] = '\0';
1102                     TRACE("Read string value %s\n",
1103                      debugstr_w(prop->u.pwszVal));
1104                 }
1105                 else
1106                 {
1107                     /* Make sure it's NULL-terminated */
1108                     prop->u.pszVal[count - 1] = '\0';
1109                     TRACE("Read string value %s\n", debugstr_a(prop->u.pszVal));
1110                 }
1111             }
1112             else
1113                 hr = STG_E_INSUFFICIENTMEMORY;
1114         }
1115         break;
1116     }
1117     case VT_LPWSTR:
1118     {
1119         DWORD count;
1120
1121         StorageUtl_ReadDWord(data, 0, &count);
1122         prop->u.pwszVal = CoTaskMemAlloc(count * sizeof(WCHAR));
1123         if (prop->u.pwszVal)
1124         {
1125             memcpy(prop->u.pwszVal, data + sizeof(DWORD),
1126              count * sizeof(WCHAR));
1127             /* make sure string is NULL-terminated */
1128             prop->u.pwszVal[count - 1] = '\0';
1129             PropertyStorage_ByteSwapString(prop->u.pwszVal, count);
1130             TRACE("Read string value %s\n", debugstr_w(prop->u.pwszVal));
1131         }
1132         else
1133             hr = STG_E_INSUFFICIENTMEMORY;
1134         break;
1135     }
1136     case VT_FILETIME:
1137         StorageUtl_ReadULargeInteger(data, 0,
1138          (ULARGE_INTEGER *)&prop->u.filetime);
1139         break;
1140     case VT_CF:
1141         {
1142             DWORD len = 0, tag = 0;
1143
1144             StorageUtl_ReadDWord(data, 0, &len);
1145             StorageUtl_ReadDWord(data, 4, &tag);
1146             if (len > 8)
1147             {
1148                 len -= 8;
1149                 prop->u.pclipdata = CoTaskMemAlloc(sizeof (CLIPDATA));
1150                 prop->u.pclipdata->cbSize = len;
1151                 prop->u.pclipdata->ulClipFmt = tag;
1152                 prop->u.pclipdata->pClipData = CoTaskMemAlloc(len);
1153                 memcpy(prop->u.pclipdata->pClipData, data+8, len);
1154             }
1155             else
1156                 hr = STG_E_INVALIDPARAMETER;
1157         }
1158         break;
1159     default:
1160         FIXME("unsupported type %d\n", prop->vt);
1161         hr = STG_E_INVALIDPARAMETER;
1162     }
1163     return hr;
1164 }
1165
1166 static HRESULT PropertyStorage_ReadHeaderFromStream(IStream *stm,
1167  PROPERTYSETHEADER *hdr)
1168 {
1169     BYTE buf[sizeof(PROPERTYSETHEADER)];
1170     ULONG count = 0;
1171     HRESULT hr;
1172
1173     assert(stm);
1174     assert(hdr);
1175     hr = IStream_Read(stm, buf, sizeof(buf), &count);
1176     if (SUCCEEDED(hr))
1177     {
1178         if (count != sizeof(buf))
1179         {
1180             WARN("read only %ld\n", count);
1181             hr = STG_E_INVALIDHEADER;
1182         }
1183         else
1184         {
1185             StorageUtl_ReadWord(buf, offsetof(PROPERTYSETHEADER, wByteOrder),
1186              &hdr->wByteOrder);
1187             StorageUtl_ReadWord(buf, offsetof(PROPERTYSETHEADER, wFormat),
1188              &hdr->wFormat);
1189             StorageUtl_ReadDWord(buf, offsetof(PROPERTYSETHEADER, dwOSVer),
1190              &hdr->dwOSVer);
1191             StorageUtl_ReadGUID(buf, offsetof(PROPERTYSETHEADER, clsid),
1192              &hdr->clsid);
1193             StorageUtl_ReadDWord(buf, offsetof(PROPERTYSETHEADER, reserved),
1194              &hdr->reserved);
1195         }
1196     }
1197     TRACE("returning 0x%08lx\n", hr);
1198     return hr;
1199 }
1200
1201 static HRESULT PropertyStorage_ReadFmtIdOffsetFromStream(IStream *stm,
1202  FORMATIDOFFSET *fmt)
1203 {
1204     BYTE buf[sizeof(FORMATIDOFFSET)];
1205     ULONG count = 0;
1206     HRESULT hr;
1207
1208     assert(stm);
1209     assert(fmt);
1210     hr = IStream_Read(stm, buf, sizeof(buf), &count);
1211     if (SUCCEEDED(hr))
1212     {
1213         if (count != sizeof(buf))
1214         {
1215             WARN("read only %ld\n", count);
1216             hr = STG_E_INVALIDHEADER;
1217         }
1218         else
1219         {
1220             StorageUtl_ReadGUID(buf, offsetof(FORMATIDOFFSET, fmtid),
1221              &fmt->fmtid);
1222             StorageUtl_ReadDWord(buf, offsetof(FORMATIDOFFSET, dwOffset),
1223              &fmt->dwOffset);
1224         }
1225     }
1226     TRACE("returning 0x%08lx\n", hr);
1227     return hr;
1228 }
1229
1230 static HRESULT PropertyStorage_ReadSectionHeaderFromStream(IStream *stm,
1231  PROPERTYSECTIONHEADER *hdr)
1232 {
1233     BYTE buf[sizeof(PROPERTYSECTIONHEADER)];
1234     ULONG count = 0;
1235     HRESULT hr;
1236
1237     assert(stm);
1238     assert(hdr);
1239     hr = IStream_Read(stm, buf, sizeof(buf), &count);
1240     if (SUCCEEDED(hr))
1241     {
1242         if (count != sizeof(buf))
1243         {
1244             WARN("read only %ld\n", count);
1245             hr = STG_E_INVALIDHEADER;
1246         }
1247         else
1248         {
1249             StorageUtl_ReadDWord(buf, offsetof(PROPERTYSECTIONHEADER,
1250              cbSection), &hdr->cbSection);
1251             StorageUtl_ReadDWord(buf, offsetof(PROPERTYSECTIONHEADER,
1252              cProperties), &hdr->cProperties);
1253         }
1254     }
1255     TRACE("returning 0x%08lx\n", hr);
1256     return hr;
1257 }
1258
1259 static HRESULT PropertyStorage_ReadFromStream(PropertyStorage_impl *This)
1260 {
1261     PROPERTYSETHEADER hdr;
1262     FORMATIDOFFSET fmtOffset;
1263     PROPERTYSECTIONHEADER sectionHdr;
1264     LARGE_INTEGER seek;
1265     ULONG i;
1266     STATSTG stat;
1267     HRESULT hr;
1268     BYTE *buf = NULL;
1269     ULONG count = 0;
1270     DWORD dictOffset = 0;
1271
1272     This->dirty = FALSE;
1273     This->highestProp = 0;
1274     hr = IStream_Stat(This->stm, &stat, STATFLAG_NONAME);
1275     if (FAILED(hr))
1276         goto end;
1277     if (stat.cbSize.u.HighPart)
1278     {
1279         WARN("stream too big\n");
1280         /* maximum size varies, but it can't be this big */
1281         hr = STG_E_INVALIDHEADER;
1282         goto end;
1283     }
1284     if (stat.cbSize.u.LowPart == 0)
1285     {
1286         /* empty stream is okay */
1287         hr = S_OK;
1288         goto end;
1289     }
1290     else if (stat.cbSize.u.LowPart < sizeof(PROPERTYSETHEADER) +
1291      sizeof(FORMATIDOFFSET))
1292     {
1293         WARN("stream too small\n");
1294         hr = STG_E_INVALIDHEADER;
1295         goto end;
1296     }
1297     seek.QuadPart = 0;
1298     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1299     if (FAILED(hr))
1300         goto end;
1301     hr = PropertyStorage_ReadHeaderFromStream(This->stm, &hdr);
1302     /* I've only seen reserved == 1, but the article says I shouldn't disallow
1303      * higher values.
1304      */
1305     if (hdr.wByteOrder != PROPSETHDR_BYTEORDER_MAGIC || hdr.reserved < 1)
1306     {
1307         WARN("bad magic in prop set header\n");
1308         hr = STG_E_INVALIDHEADER;
1309         goto end;
1310     }
1311     if (hdr.wFormat != 0 && hdr.wFormat != 1)
1312     {
1313         WARN("bad format version %d\n", hdr.wFormat);
1314         hr = STG_E_INVALIDHEADER;
1315         goto end;
1316     }
1317     This->format = hdr.wFormat;
1318     memcpy(&This->clsid, &hdr.clsid, sizeof(This->clsid));
1319     This->originatorOS = hdr.dwOSVer;
1320     if (PROPSETHDR_OSVER_KIND(hdr.dwOSVer) == PROPSETHDR_OSVER_KIND_MAC)
1321         WARN("File comes from a Mac, strings will probably be screwed up\n");
1322     hr = PropertyStorage_ReadFmtIdOffsetFromStream(This->stm, &fmtOffset);
1323     if (FAILED(hr))
1324         goto end;
1325     if (fmtOffset.dwOffset > stat.cbSize.u.LowPart)
1326     {
1327         WARN("invalid offset %ld (stream length is %ld)\n", fmtOffset.dwOffset,
1328          stat.cbSize.u.LowPart);
1329         hr = STG_E_INVALIDHEADER;
1330         goto end;
1331     }
1332     /* wackiness alert: if the format ID is FMTID_DocSummaryInformation, there
1333      * follow not one, but two sections.  The first is the standard properties
1334      * for the document summary information, and the second is user-defined
1335      * properties.  This is the only case in which multiple sections are
1336      * allowed.
1337      * Reading the second stream isn't implemented yet.
1338      */
1339     hr = PropertyStorage_ReadSectionHeaderFromStream(This->stm, &sectionHdr);
1340     if (FAILED(hr))
1341         goto end;
1342     /* The section size includes the section header, so check it */
1343     if (sectionHdr.cbSection < sizeof(PROPERTYSECTIONHEADER))
1344     {
1345         WARN("section header too small, got %ld\n", sectionHdr.cbSection);
1346         hr = STG_E_INVALIDHEADER;
1347         goto end;
1348     }
1349     buf = HeapAlloc(GetProcessHeap(), 0, sectionHdr.cbSection -
1350      sizeof(PROPERTYSECTIONHEADER));
1351     if (!buf)
1352     {
1353         hr = STG_E_INSUFFICIENTMEMORY;
1354         goto end;
1355     }
1356     hr = IStream_Read(This->stm, buf, sectionHdr.cbSection -
1357      sizeof(PROPERTYSECTIONHEADER), &count);
1358     if (FAILED(hr))
1359         goto end;
1360     TRACE("Reading %ld properties:\n", sectionHdr.cProperties);
1361     for (i = 0; SUCCEEDED(hr) && i < sectionHdr.cProperties; i++)
1362     {
1363         PROPERTYIDOFFSET *idOffset = (PROPERTYIDOFFSET *)(buf +
1364          i * sizeof(PROPERTYIDOFFSET));
1365
1366         if (idOffset->dwOffset < sizeof(PROPERTYSECTIONHEADER) ||
1367          idOffset->dwOffset >= sectionHdr.cbSection - sizeof(DWORD))
1368             hr = STG_E_INVALIDPOINTER;
1369         else
1370         {
1371             if (idOffset->propid >= PID_FIRST_USABLE &&
1372              idOffset->propid < PID_MIN_READONLY && idOffset->propid >
1373              This->highestProp)
1374                 This->highestProp = idOffset->propid;
1375             if (idOffset->propid == PID_DICTIONARY)
1376             {
1377                 /* Don't read the dictionary yet, its entries depend on the
1378                  * code page.  Just store the offset so we know to read it
1379                  * later.
1380                  */
1381                 dictOffset = idOffset->dwOffset;
1382                 TRACE("Dictionary offset is %ld\n", dictOffset);
1383             }
1384             else
1385             {
1386                 PROPVARIANT prop;
1387
1388                 memset(&prop, 0, sizeof prop);
1389                 if (SUCCEEDED(PropertyStorage_ReadProperty(This, &prop,
1390                  buf + idOffset->dwOffset - sizeof(PROPERTYSECTIONHEADER))))
1391                 {
1392                     TRACE("Read property with ID 0x%08lx, type %d\n",
1393                      idOffset->propid, prop.vt);
1394                     switch(idOffset->propid)
1395                     {
1396                     case PID_CODEPAGE:
1397                         if (prop.vt == VT_I2)
1398                             This->codePage = (UINT)prop.u.iVal;
1399                         break;
1400                     case PID_LOCALE:
1401                         if (prop.vt == VT_I4)
1402                             This->locale = (LCID)prop.u.lVal;
1403                         break;
1404                     case PID_BEHAVIOR:
1405                         if (prop.vt == VT_I4 && prop.u.lVal)
1406                             This->grfFlags |= PROPSETFLAG_CASE_SENSITIVE;
1407                         /* The format should already be 1, but just in case */
1408                         This->format = 1;
1409                         break;
1410                     default:
1411                         hr = PropertyStorage_StorePropWithId(This,
1412                          idOffset->propid, &prop, This->codePage);
1413                     }
1414                 }
1415             }
1416         }
1417     }
1418     if (!This->codePage)
1419     {
1420         /* default to Unicode unless told not to, as specified here:
1421          * http://msdn.microsoft.com/library/en-us/stg/stg/names_in_istorage.asp
1422          */
1423         if (This->grfFlags & PROPSETFLAG_ANSI)
1424             This->codePage = GetACP();
1425         else
1426             This->codePage = CP_UNICODE;
1427     }
1428     if (!This->locale)
1429         This->locale = LOCALE_SYSTEM_DEFAULT;
1430     TRACE("Code page is %d, locale is %ld\n", This->codePage, This->locale);
1431     if (dictOffset)
1432         hr = PropertyStorage_ReadDictionary(This,
1433          buf + dictOffset - sizeof(PROPERTYSECTIONHEADER));
1434
1435 end:
1436     HeapFree(GetProcessHeap(), 0, buf);
1437     if (FAILED(hr))
1438     {
1439         dictionary_destroy(This->name_to_propid);
1440         This->name_to_propid = NULL;
1441         dictionary_destroy(This->propid_to_name);
1442         This->propid_to_name = NULL;
1443         dictionary_destroy(This->propid_to_prop);
1444         This->propid_to_prop = NULL;
1445     }
1446     return hr;
1447 }
1448
1449 static void PropertyStorage_MakeHeader(PropertyStorage_impl *This,
1450  PROPERTYSETHEADER *hdr)
1451 {
1452     assert(hdr);
1453     StorageUtl_WriteWord((BYTE *)&hdr->wByteOrder, 0,
1454      PROPSETHDR_BYTEORDER_MAGIC);
1455     StorageUtl_WriteWord((BYTE *)&hdr->wFormat, 0, This->format);
1456     StorageUtl_WriteDWord((BYTE *)&hdr->dwOSVer, 0, This->originatorOS);
1457     StorageUtl_WriteGUID((BYTE *)&hdr->clsid, 0, &This->clsid);
1458     StorageUtl_WriteDWord((BYTE *)&hdr->reserved, 0, 1);
1459 }
1460
1461 static void PropertyStorage_MakeFmtIdOffset(PropertyStorage_impl *This,
1462  FORMATIDOFFSET *fmtOffset)
1463 {
1464     assert(fmtOffset);
1465     StorageUtl_WriteGUID((BYTE *)fmtOffset, 0, &This->fmtid);
1466     StorageUtl_WriteDWord((BYTE *)fmtOffset, offsetof(FORMATIDOFFSET, dwOffset),
1467      sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET));
1468 }
1469
1470 static void PropertyStorage_MakeSectionHdr(DWORD cbSection, DWORD numProps,
1471  PROPERTYSECTIONHEADER *hdr)
1472 {
1473     assert(hdr);
1474     StorageUtl_WriteDWord((BYTE *)hdr, 0, cbSection);
1475     StorageUtl_WriteDWord((BYTE *)hdr,
1476      offsetof(PROPERTYSECTIONHEADER, cProperties), numProps);
1477 }
1478
1479 static void PropertyStorage_MakePropertyIdOffset(DWORD propid, DWORD dwOffset,
1480  PROPERTYIDOFFSET *propIdOffset)
1481 {
1482     assert(propIdOffset);
1483     StorageUtl_WriteDWord((BYTE *)propIdOffset, 0, propid);
1484     StorageUtl_WriteDWord((BYTE *)propIdOffset,
1485      offsetof(PROPERTYIDOFFSET, dwOffset), dwOffset);
1486 }
1487
1488 struct DictionaryClosure
1489 {
1490     HRESULT hr;
1491     DWORD bytesWritten;
1492 };
1493
1494 static BOOL PropertyStorage_DictionaryWriter(const void *key,
1495  const void *value, void *extra, void *closure)
1496 {
1497     PropertyStorage_impl *This = (PropertyStorage_impl *)extra;
1498     struct DictionaryClosure *c = (struct DictionaryClosure *)closure;
1499     DWORD propid;
1500     ULONG count;
1501
1502     assert(key);
1503     assert(closure);
1504     StorageUtl_WriteDWord((LPBYTE)&propid, 0, (DWORD)value);
1505     c->hr = IStream_Write(This->stm, &propid, sizeof(propid), &count);
1506     if (FAILED(c->hr))
1507         goto end;
1508     c->bytesWritten += sizeof(DWORD);
1509     if (This->codePage == CP_UNICODE)
1510     {
1511         DWORD keyLen, pad = 0;
1512
1513         StorageUtl_WriteDWord((LPBYTE)&keyLen, 0,
1514          (lstrlenW((LPWSTR)key) + 1) * sizeof(WCHAR));
1515         c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
1516         if (FAILED(c->hr))
1517             goto end;
1518         c->bytesWritten += sizeof(DWORD);
1519         /* Rather than allocate a copy, I'll swap the string to little-endian
1520          * in-place, write it, then swap it back.
1521          */
1522         PropertyStorage_ByteSwapString(key, keyLen);
1523         c->hr = IStream_Write(This->stm, key, keyLen, &count);
1524         PropertyStorage_ByteSwapString(key, keyLen);
1525         if (FAILED(c->hr))
1526             goto end;
1527         c->bytesWritten += keyLen;
1528         if (keyLen % sizeof(DWORD))
1529         {
1530             c->hr = IStream_Write(This->stm, &pad,
1531              sizeof(DWORD) - keyLen % sizeof(DWORD), &count);
1532             if (FAILED(c->hr))
1533                 goto end;
1534             c->bytesWritten += sizeof(DWORD) - keyLen % sizeof(DWORD);
1535         }
1536     }
1537     else
1538     {
1539         DWORD keyLen;
1540
1541         StorageUtl_WriteDWord((LPBYTE)&keyLen, 0, strlen((LPCSTR)key) + 1);
1542         c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
1543         if (FAILED(c->hr))
1544             goto end;
1545         c->bytesWritten += sizeof(DWORD);
1546         c->hr = IStream_Write(This->stm, key, keyLen, &count);
1547         if (FAILED(c->hr))
1548             goto end;
1549         c->bytesWritten += keyLen;
1550     }
1551 end:
1552     return SUCCEEDED(c->hr);
1553 }
1554
1555 #define SECTIONHEADER_OFFSET sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET)
1556
1557 /* Writes the dictionary to the stream.  Assumes without checking that the
1558  * dictionary isn't empty.
1559  */
1560 static HRESULT PropertyStorage_WriteDictionaryToStream(
1561  PropertyStorage_impl *This, DWORD *sectionOffset)
1562 {
1563     HRESULT hr;
1564     LARGE_INTEGER seek;
1565     PROPERTYIDOFFSET propIdOffset;
1566     ULONG count;
1567     DWORD dwTemp;
1568     struct DictionaryClosure closure;
1569
1570     assert(sectionOffset);
1571
1572     /* The dictionary's always the first property written, so seek to its
1573      * spot.
1574      */
1575     seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER);
1576     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1577     if (FAILED(hr))
1578         goto end;
1579     PropertyStorage_MakePropertyIdOffset(PID_DICTIONARY, *sectionOffset,
1580      &propIdOffset);
1581     hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
1582     if (FAILED(hr))
1583         goto end;
1584
1585     seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
1586     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1587     if (FAILED(hr))
1588         goto end;
1589     StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0,
1590      dictionary_num_entries(This->name_to_propid));
1591     hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
1592     if (FAILED(hr))
1593         goto end;
1594     *sectionOffset += sizeof(dwTemp);
1595
1596     closure.hr = S_OK;
1597     closure.bytesWritten = 0;
1598     dictionary_enumerate(This->name_to_propid, PropertyStorage_DictionaryWriter,
1599      &closure);
1600     hr = closure.hr;
1601     if (FAILED(hr))
1602         goto end;
1603     *sectionOffset += closure.bytesWritten;
1604     if (closure.bytesWritten % sizeof(DWORD))
1605     {
1606         TRACE("adding %ld bytes of padding\n", sizeof(DWORD) -
1607          closure.bytesWritten % sizeof(DWORD));
1608         *sectionOffset += sizeof(DWORD) - closure.bytesWritten % sizeof(DWORD);
1609     }
1610
1611 end:
1612     return hr;
1613 }
1614
1615 static HRESULT PropertyStorage_WritePropertyToStream(PropertyStorage_impl *This,
1616  DWORD propNum, DWORD propid, PROPVARIANT *var, DWORD *sectionOffset)
1617 {
1618     HRESULT hr;
1619     LARGE_INTEGER seek;
1620     PROPERTYIDOFFSET propIdOffset;
1621     ULONG count;
1622     DWORD dwType, bytesWritten;
1623
1624     assert(var);
1625     assert(sectionOffset);
1626
1627     TRACE("%p, %ld, 0x%08lx, (%d), (%ld)\n", This, propNum, propid, var->vt,
1628      *sectionOffset);
1629
1630     seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER) +
1631      propNum * sizeof(PROPERTYIDOFFSET);
1632     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1633     if (FAILED(hr))
1634         goto end;
1635     PropertyStorage_MakePropertyIdOffset(propid, *sectionOffset, &propIdOffset);
1636     hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
1637     if (FAILED(hr))
1638         goto end;
1639
1640     seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
1641     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1642     if (FAILED(hr))
1643         goto end;
1644     StorageUtl_WriteDWord((LPBYTE)&dwType, 0, var->vt);
1645     hr = IStream_Write(This->stm, &dwType, sizeof(dwType), &count);
1646     if (FAILED(hr))
1647         goto end;
1648     *sectionOffset += sizeof(dwType);
1649
1650     switch (var->vt)
1651     {
1652     case VT_EMPTY:
1653     case VT_NULL:
1654         bytesWritten = 0;
1655         break;
1656     case VT_I1:
1657     case VT_UI1:
1658         hr = IStream_Write(This->stm, &var->u.cVal, sizeof(var->u.cVal),
1659          &count);
1660         bytesWritten = count;
1661         break;
1662     case VT_I2:
1663     case VT_UI2:
1664     {
1665         WORD wTemp;
1666
1667         StorageUtl_WriteWord((LPBYTE)&wTemp, 0, var->u.iVal);
1668         hr = IStream_Write(This->stm, &wTemp, sizeof(wTemp), &count);
1669         bytesWritten = count;
1670         break;
1671     }
1672     case VT_I4:
1673     case VT_UI4:
1674     {
1675         DWORD dwTemp;
1676
1677         StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, var->u.lVal);
1678         hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
1679         bytesWritten = count;
1680         break;
1681     }
1682     case VT_LPSTR:
1683     {
1684         DWORD len, dwTemp;
1685
1686         if (This->codePage == CP_UNICODE)
1687             len = (lstrlenW(var->u.pwszVal) + 1) * sizeof(WCHAR);
1688         else
1689             len = lstrlenA(var->u.pszVal) + 1;
1690         StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, len);
1691         hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
1692         if (FAILED(hr))
1693             goto end;
1694         hr = IStream_Write(This->stm, var->u.pszVal, len, &count);
1695         bytesWritten = count + sizeof(DWORD);
1696         break;
1697     }
1698     case VT_LPWSTR:
1699     {
1700         DWORD len = lstrlenW(var->u.pwszVal) + 1, dwTemp;
1701
1702         StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, len);
1703         hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
1704         if (FAILED(hr))
1705             goto end;
1706         hr = IStream_Write(This->stm, var->u.pwszVal, len * sizeof(WCHAR),
1707          &count);
1708         bytesWritten = count + sizeof(DWORD);
1709         break;
1710     }
1711     case VT_FILETIME:
1712     {
1713         FILETIME temp;
1714
1715         StorageUtl_WriteULargeInteger((BYTE *)&temp, 0,
1716          (ULARGE_INTEGER *)&var->u.filetime);
1717         hr = IStream_Write(This->stm, &temp, sizeof(FILETIME), &count);
1718         bytesWritten = count;
1719         break;
1720     }
1721     case VT_CF:
1722     {
1723         DWORD cf_hdr[2], len;
1724
1725         len = var->u.pclipdata->cbSize;
1726         StorageUtl_WriteDWord((LPBYTE)&cf_hdr[0], 0, len + 8);
1727         StorageUtl_WriteDWord((LPBYTE)&cf_hdr[1], 0, var->u.pclipdata->ulClipFmt);
1728         hr = IStream_Write(This->stm, &cf_hdr, sizeof(cf_hdr), &count);
1729         if (FAILED(hr))
1730             goto end;
1731         hr = IStream_Write(This->stm, &var->u.pclipdata->pClipData, len, &count);
1732         if (FAILED(hr))
1733             goto end;
1734         bytesWritten = count + sizeof cf_hdr;
1735         break;
1736     }
1737     default:
1738         FIXME("unsupported type: %d\n", var->vt);
1739         return STG_E_INVALIDPARAMETER;
1740     }
1741
1742     if (SUCCEEDED(hr))
1743     {
1744         *sectionOffset += bytesWritten;
1745         if (bytesWritten % sizeof(DWORD))
1746         {
1747             TRACE("adding %ld bytes of padding\n", sizeof(DWORD) -
1748              bytesWritten % sizeof(DWORD));
1749             *sectionOffset += sizeof(DWORD) - bytesWritten % sizeof(DWORD);
1750         }
1751     }
1752
1753 end:
1754     return hr;
1755 }
1756
1757 struct PropertyClosure
1758 {
1759     HRESULT hr;
1760     DWORD   propNum;
1761     DWORD  *sectionOffset;
1762 };
1763
1764 static BOOL PropertyStorage_PropertiesWriter(const void *key, const void *value,
1765  void *extra, void *closure)
1766 {
1767     PropertyStorage_impl *This = (PropertyStorage_impl *)extra;
1768     struct PropertyClosure *c = (struct PropertyClosure *)closure;
1769
1770     assert(key);
1771     assert(value);
1772     assert(extra);
1773     assert(closure);
1774     c->hr = PropertyStorage_WritePropertyToStream(This,
1775      c->propNum++, (DWORD)key, (PROPVARIANT *)value, c->sectionOffset);
1776     return SUCCEEDED(c->hr);
1777 }
1778
1779 static HRESULT PropertyStorage_WritePropertiesToStream(
1780  PropertyStorage_impl *This, DWORD startingPropNum, DWORD *sectionOffset)
1781 {
1782     struct PropertyClosure closure;
1783
1784     assert(sectionOffset);
1785     closure.hr = S_OK;
1786     closure.propNum = startingPropNum;
1787     closure.sectionOffset = sectionOffset;
1788     dictionary_enumerate(This->propid_to_prop, PropertyStorage_PropertiesWriter,
1789      &closure);
1790     return closure.hr;
1791 }
1792
1793 static HRESULT PropertyStorage_WriteHeadersToStream(PropertyStorage_impl *This)
1794 {
1795     HRESULT hr;
1796     ULONG count = 0;
1797     LARGE_INTEGER seek = { {0} };
1798     PROPERTYSETHEADER hdr;
1799     FORMATIDOFFSET fmtOffset;
1800
1801     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1802     if (FAILED(hr))
1803         goto end;
1804     PropertyStorage_MakeHeader(This, &hdr);
1805     hr = IStream_Write(This->stm, &hdr, sizeof(hdr), &count);
1806     if (FAILED(hr))
1807         goto end;
1808     if (count != sizeof(hdr))
1809     {
1810         hr = STG_E_WRITEFAULT;
1811         goto end;
1812     }
1813
1814     PropertyStorage_MakeFmtIdOffset(This, &fmtOffset);
1815     hr = IStream_Write(This->stm, &fmtOffset, sizeof(fmtOffset), &count);
1816     if (FAILED(hr))
1817         goto end;
1818     if (count != sizeof(fmtOffset))
1819     {
1820         hr = STG_E_WRITEFAULT;
1821         goto end;
1822     }
1823     hr = S_OK;
1824
1825 end:
1826     return hr;
1827 }
1828
1829 static HRESULT PropertyStorage_WriteToStream(PropertyStorage_impl *This)
1830 {
1831     PROPERTYSECTIONHEADER sectionHdr;
1832     HRESULT hr;
1833     ULONG count;
1834     LARGE_INTEGER seek;
1835     DWORD numProps, prop, sectionOffset, dwTemp;
1836     PROPVARIANT var;
1837
1838     PropertyStorage_WriteHeadersToStream(This);
1839
1840     /* Count properties.  Always at least one property, the code page */
1841     numProps = 1;
1842     if (dictionary_num_entries(This->name_to_propid))
1843         numProps++;
1844     if (This->locale != LOCALE_SYSTEM_DEFAULT)
1845         numProps++;
1846     if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
1847         numProps++;
1848     numProps += dictionary_num_entries(This->propid_to_prop);
1849
1850     /* Write section header with 0 bytes right now, I'll adjust it after
1851      * writing properties.
1852      */
1853     PropertyStorage_MakeSectionHdr(0, numProps, &sectionHdr);
1854     seek.QuadPart = SECTIONHEADER_OFFSET;
1855     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1856     if (FAILED(hr))
1857         goto end;
1858     hr = IStream_Write(This->stm, &sectionHdr, sizeof(sectionHdr), &count);
1859     if (FAILED(hr))
1860         goto end;
1861
1862     prop = 0;
1863     sectionOffset = sizeof(PROPERTYSECTIONHEADER) +
1864      numProps * sizeof(PROPERTYIDOFFSET);
1865
1866     if (dictionary_num_entries(This->name_to_propid))
1867     {
1868         prop++;
1869         hr = PropertyStorage_WriteDictionaryToStream(This, &sectionOffset);
1870         if (FAILED(hr))
1871             goto end;
1872     }
1873
1874     PropVariantInit(&var);
1875
1876     var.vt = VT_I2;
1877     var.u.iVal = This->codePage;
1878     hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_CODEPAGE,
1879      &var, &sectionOffset);
1880     if (FAILED(hr))
1881         goto end;
1882
1883     if (This->locale != LOCALE_SYSTEM_DEFAULT)
1884     {
1885         var.vt = VT_I4;
1886         var.u.lVal = This->locale;
1887         hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_LOCALE,
1888          &var, &sectionOffset);
1889         if (FAILED(hr))
1890             goto end;
1891     }
1892
1893     if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
1894     {
1895         var.vt = VT_I4;
1896         var.u.lVal = 1;
1897         hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_BEHAVIOR,
1898          &var, &sectionOffset);
1899         if (FAILED(hr))
1900             goto end;
1901     }
1902
1903     hr = PropertyStorage_WritePropertiesToStream(This, prop, &sectionOffset);
1904     if (FAILED(hr))
1905         goto end;
1906
1907     /* Now write the byte count of the section */
1908     seek.QuadPart = SECTIONHEADER_OFFSET;
1909     hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1910     if (FAILED(hr))
1911         goto end;
1912     StorageUtl_WriteDWord((LPBYTE)&dwTemp, 0, sectionOffset);
1913     hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
1914
1915 end:
1916     return hr;
1917 }
1918
1919 /***********************************************************************
1920  * PropertyStorage_Construct
1921  */
1922 static void PropertyStorage_DestroyDictionaries(PropertyStorage_impl *This)
1923 {
1924     dictionary_destroy(This->name_to_propid);
1925     This->name_to_propid = NULL;
1926     dictionary_destroy(This->propid_to_name);
1927     This->propid_to_name = NULL;
1928     dictionary_destroy(This->propid_to_prop);
1929     This->propid_to_prop = NULL;
1930 }
1931
1932 static HRESULT PropertyStorage_CreateDictionaries(PropertyStorage_impl *This)
1933 {
1934     HRESULT hr = S_OK;
1935
1936     This->name_to_propid = dictionary_create(
1937      PropertyStorage_PropNameCompare, PropertyStorage_PropNameDestroy,
1938      This);
1939     if (!This->name_to_propid)
1940     {
1941         hr = STG_E_INSUFFICIENTMEMORY;
1942         goto end;
1943     }
1944     This->propid_to_name = dictionary_create(PropertyStorage_PropCompare,
1945      NULL, This);
1946     if (!This->propid_to_name)
1947     {
1948         hr = STG_E_INSUFFICIENTMEMORY;
1949         goto end;
1950     }
1951     This->propid_to_prop = dictionary_create(PropertyStorage_PropCompare,
1952      PropertyStorage_PropertyDestroy, This);
1953     if (!This->propid_to_prop)
1954     {
1955         hr = STG_E_INSUFFICIENTMEMORY;
1956         goto end;
1957     }
1958 end:
1959     if (FAILED(hr))
1960         PropertyStorage_DestroyDictionaries(This);
1961     return hr;
1962 }
1963
1964 static HRESULT PropertyStorage_BaseConstruct(IStream *stm,
1965  REFFMTID rfmtid, DWORD grfMode, PropertyStorage_impl **pps)
1966 {
1967     HRESULT hr = S_OK;
1968
1969     assert(pps);
1970     assert(rfmtid);
1971     *pps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof **pps);
1972     if (!*pps)
1973         return E_OUTOFMEMORY;
1974
1975     (*pps)->vtbl = &IPropertyStorage_Vtbl;
1976     (*pps)->ref = 1;
1977     InitializeCriticalSection(&(*pps)->cs);
1978     (*pps)->stm = stm;
1979     memcpy(&(*pps)->fmtid, rfmtid, sizeof((*pps)->fmtid));
1980     (*pps)->grfMode = grfMode;
1981
1982     hr = PropertyStorage_CreateDictionaries(*pps);
1983     if (FAILED(hr))
1984     {
1985         IStream_Release(stm);
1986         DeleteCriticalSection(&(*pps)->cs);
1987         HeapFree(GetProcessHeap(), 0, *pps);
1988         *pps = NULL;
1989     }
1990
1991     return hr;
1992 }
1993
1994 static HRESULT PropertyStorage_ConstructFromStream(IStream *stm,
1995  REFFMTID rfmtid, DWORD grfMode, IPropertyStorage** pps)
1996 {
1997     PropertyStorage_impl *ps;
1998     HRESULT hr;
1999
2000     assert(pps);
2001     hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
2002     if (SUCCEEDED(hr))
2003     {
2004         hr = PropertyStorage_ReadFromStream(ps);
2005         if (SUCCEEDED(hr))
2006         {
2007             *pps = (IPropertyStorage *)ps;
2008             TRACE("PropertyStorage %p constructed\n", ps);
2009             hr = S_OK;
2010         }
2011         else
2012         {
2013             PropertyStorage_DestroyDictionaries(ps);
2014             HeapFree(GetProcessHeap(), 0, ps);
2015         }
2016     }
2017     return hr;
2018 }
2019
2020 static HRESULT PropertyStorage_ConstructEmpty(IStream *stm,
2021  REFFMTID rfmtid, DWORD grfFlags, DWORD grfMode, IPropertyStorage** pps)
2022 {
2023     PropertyStorage_impl *ps;
2024     HRESULT hr;
2025
2026     assert(pps);
2027     hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
2028     if (SUCCEEDED(hr))
2029     {
2030         ps->format = 0;
2031         ps->grfFlags = grfFlags;
2032         if (ps->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
2033             ps->format = 1;
2034         /* default to Unicode unless told not to, as specified here:
2035          * http://msdn.microsoft.com/library/en-us/stg/stg/names_in_istorage.asp
2036          */
2037         if (ps->grfFlags & PROPSETFLAG_ANSI)
2038             ps->codePage = GetACP();
2039         else
2040             ps->codePage = CP_UNICODE;
2041         ps->locale = LOCALE_SYSTEM_DEFAULT;
2042         TRACE("Code page is %d, locale is %ld\n", ps->codePage, ps->locale);
2043         *pps = (IPropertyStorage *)ps;
2044         TRACE("PropertyStorage %p constructed\n", ps);
2045         hr = S_OK;
2046     }
2047     return hr;
2048 }
2049
2050
2051 /***********************************************************************
2052  * Implementation of IPropertySetStorage
2053  */
2054
2055 /************************************************************************
2056  * IPropertySetStorage_fnQueryInterface (IUnknown)
2057  *
2058  *  This method forwards to the common QueryInterface implementation
2059  */
2060 static HRESULT WINAPI IPropertySetStorage_fnQueryInterface(
2061     IPropertySetStorage *ppstg,
2062     REFIID riid,
2063     void** ppvObject)
2064 {
2065     StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2066     return IStorage_QueryInterface( (IStorage*)This, riid, ppvObject );
2067 }
2068
2069 /************************************************************************
2070  * IPropertySetStorage_fnAddRef (IUnknown)
2071  *
2072  *  This method forwards to the common AddRef implementation
2073  */
2074 static ULONG WINAPI IPropertySetStorage_fnAddRef(
2075     IPropertySetStorage *ppstg)
2076 {
2077     StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2078     return IStorage_AddRef( (IStorage*)This );
2079 }
2080
2081 /************************************************************************
2082  * IPropertySetStorage_fnRelease (IUnknown)
2083  *
2084  *  This method forwards to the common Release implementation
2085  */
2086 static ULONG WINAPI IPropertySetStorage_fnRelease(
2087     IPropertySetStorage *ppstg)
2088 {
2089     StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2090     return IStorage_Release( (IStorage*)This );
2091 }
2092
2093 /************************************************************************
2094  * IPropertySetStorage_fnCreate (IPropertySetStorage)
2095  */
2096 static HRESULT WINAPI IPropertySetStorage_fnCreate(
2097     IPropertySetStorage *ppstg,
2098     REFFMTID rfmtid,
2099     const CLSID* pclsid,
2100     DWORD grfFlags,
2101     DWORD grfMode,
2102     IPropertyStorage** ppprstg)
2103 {
2104     StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2105     WCHAR name[CCH_MAX_PROPSTG_NAME];
2106     IStream *stm = NULL;
2107     HRESULT r;
2108
2109     TRACE("%p %s %08lx %08lx %p\n", This, debugstr_guid(rfmtid), grfFlags,
2110      grfMode, ppprstg);
2111
2112     /* be picky */
2113     if (grfMode != (STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE))
2114     {
2115         r = STG_E_INVALIDFLAG;
2116         goto end;
2117     }
2118
2119     if (!rfmtid)
2120     {
2121         r = E_INVALIDARG;
2122         goto end;
2123     }
2124
2125     /* FIXME: if (grfFlags & PROPSETFLAG_NONSIMPLE), we need to create a
2126      * storage, not a stream.  For now, disallow it.
2127      */
2128     if (grfFlags & PROPSETFLAG_NONSIMPLE)
2129     {
2130         FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
2131         r = STG_E_INVALIDFLAG;
2132         goto end;
2133     }
2134
2135     r = FmtIdToPropStgName(rfmtid, name);
2136     if (FAILED(r))
2137         goto end;
2138
2139     r = IStorage_CreateStream( (IStorage*)This, name, grfMode, 0, 0, &stm );
2140     if (FAILED(r))
2141         goto end;
2142
2143     r = PropertyStorage_ConstructEmpty(stm, rfmtid, grfFlags, grfMode, ppprstg);
2144
2145 end:
2146     TRACE("returning 0x%08lx\n", r);
2147     return r;
2148 }
2149
2150 /************************************************************************
2151  * IPropertySetStorage_fnOpen (IPropertySetStorage)
2152  */
2153 static HRESULT WINAPI IPropertySetStorage_fnOpen(
2154     IPropertySetStorage *ppstg,
2155     REFFMTID rfmtid,
2156     DWORD grfMode,
2157     IPropertyStorage** ppprstg)
2158 {
2159     StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2160     IStream *stm = NULL;
2161     WCHAR name[CCH_MAX_PROPSTG_NAME];
2162     HRESULT r;
2163
2164     TRACE("%p %s %08lx %p\n", This, debugstr_guid(rfmtid), grfMode, ppprstg);
2165
2166     /* be picky */
2167     if (grfMode != (STGM_READWRITE|STGM_SHARE_EXCLUSIVE) &&
2168         grfMode != (STGM_READ|STGM_SHARE_EXCLUSIVE))
2169     {
2170         r = STG_E_INVALIDFLAG;
2171         goto end;
2172     }
2173
2174     if (!rfmtid)
2175     {
2176         r = E_INVALIDARG;
2177         goto end;
2178     }
2179
2180     r = FmtIdToPropStgName(rfmtid, name);
2181     if (FAILED(r))
2182         goto end;
2183
2184     r = IStorage_OpenStream((IStorage*) This, name, 0, grfMode, 0, &stm );
2185     if (FAILED(r))
2186         goto end;
2187
2188     r = PropertyStorage_ConstructFromStream(stm, rfmtid, grfMode, ppprstg);
2189
2190 end:
2191     TRACE("returning 0x%08lx\n", r);
2192     return r;
2193 }
2194
2195 /************************************************************************
2196  * IPropertySetStorage_fnDelete (IPropertySetStorage)
2197  */
2198 static HRESULT WINAPI IPropertySetStorage_fnDelete(
2199     IPropertySetStorage *ppstg,
2200     REFFMTID rfmtid)
2201 {
2202     StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2203     IStorage *stg = NULL;
2204     WCHAR name[CCH_MAX_PROPSTG_NAME];
2205     HRESULT r;
2206
2207     TRACE("%p %s\n", This, debugstr_guid(rfmtid));
2208
2209     if (!rfmtid)
2210         return E_INVALIDARG;
2211
2212     r = FmtIdToPropStgName(rfmtid, name);
2213     if (FAILED(r))
2214         return r;
2215
2216     stg = (IStorage*) This;
2217     return IStorage_DestroyElement(stg, name);
2218 }
2219
2220 /************************************************************************
2221  * IPropertySetStorage_fnEnum (IPropertySetStorage)
2222  */
2223 static HRESULT WINAPI IPropertySetStorage_fnEnum(
2224     IPropertySetStorage *ppstg,
2225     IEnumSTATPROPSETSTG** ppenum)
2226 {
2227     StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2228     return create_EnumSTATPROPSETSTG(This, ppenum);
2229 }
2230
2231 /************************************************************************
2232  * Implement IEnumSTATPROPSETSTG using enumx
2233  */
2234 static HRESULT WINAPI IEnumSTATPROPSETSTG_fnQueryInterface(
2235     IEnumSTATPROPSETSTG *iface,
2236     REFIID riid,
2237     void** ppvObject)
2238 {
2239     return enumx_QueryInterface((enumx_impl*)iface, riid, ppvObject);
2240 }
2241
2242 static ULONG WINAPI IEnumSTATPROPSETSTG_fnAddRef(
2243     IEnumSTATPROPSETSTG *iface)
2244 {
2245     return enumx_AddRef((enumx_impl*)iface);
2246 }
2247
2248 static ULONG WINAPI IEnumSTATPROPSETSTG_fnRelease(
2249     IEnumSTATPROPSETSTG *iface)
2250 {
2251     return enumx_Release((enumx_impl*)iface);
2252 }
2253
2254 static HRESULT WINAPI IEnumSTATPROPSETSTG_fnNext(
2255     IEnumSTATPROPSETSTG *iface,
2256     ULONG celt,
2257     STATPROPSETSTG *rgelt,
2258     ULONG *pceltFetched)
2259 {
2260     return enumx_Next((enumx_impl*)iface, celt, rgelt, pceltFetched);
2261 }
2262
2263 static HRESULT WINAPI IEnumSTATPROPSETSTG_fnSkip(
2264     IEnumSTATPROPSETSTG *iface,
2265     ULONG celt)
2266 {
2267     return enumx_Skip((enumx_impl*)iface, celt);
2268 }
2269
2270 static HRESULT WINAPI IEnumSTATPROPSETSTG_fnReset(
2271     IEnumSTATPROPSETSTG *iface)
2272 {
2273     return enumx_Reset((enumx_impl*)iface);
2274 }
2275
2276 static HRESULT WINAPI IEnumSTATPROPSETSTG_fnClone(
2277     IEnumSTATPROPSETSTG *iface,
2278     IEnumSTATPROPSETSTG **ppenum)
2279 {
2280     return enumx_Clone((enumx_impl*)iface, (enumx_impl**)ppenum);
2281 }
2282
2283 static HRESULT create_EnumSTATPROPSETSTG(
2284     StorageImpl *This,
2285     IEnumSTATPROPSETSTG** ppenum)
2286 {
2287     IStorage *stg = (IStorage*) &This->base.lpVtbl;
2288     IEnumSTATSTG *penum = NULL;
2289     STATSTG stat;
2290     ULONG count;
2291     HRESULT r;
2292     STATPROPSETSTG statpss;
2293     enumx_impl *enumx;
2294
2295     TRACE("%p %p\n", This, ppenum);
2296
2297     enumx = enumx_allocate(&IID_IEnumSTATPROPSETSTG,
2298                            &IEnumSTATPROPSETSTG_Vtbl,
2299                            sizeof (STATPROPSETSTG));
2300
2301     /* add all the property set elements into a list */
2302     r = IStorage_EnumElements(stg, 0, NULL, 0, &penum);
2303     if (FAILED(r))
2304         return E_OUTOFMEMORY;
2305
2306     while (1)
2307     {
2308         count = 0;
2309         r = IEnumSTATSTG_Next(penum, 1, &stat, &count);
2310         if (FAILED(r))
2311             break;
2312         if (!count)
2313             break;
2314         if (!stat.pwcsName)
2315             continue;
2316         if (stat.pwcsName[0] == 5 && stat.type == STGTY_STREAM)
2317         {
2318             PropStgNameToFmtId(stat.pwcsName, &statpss.fmtid);
2319             TRACE("adding %s (%s)\n", debugstr_w(stat.pwcsName),
2320                   debugstr_guid(&statpss.fmtid));
2321             statpss.mtime = stat.mtime;
2322             statpss.atime = stat.atime;
2323             statpss.ctime = stat.ctime;
2324             statpss.grfFlags = stat.grfMode;
2325             memcpy(&statpss.clsid, &stat.clsid, sizeof stat.clsid);
2326             enumx_add_element(enumx, &statpss);
2327         }
2328         CoTaskMemFree(stat.pwcsName);
2329     }
2330     IEnumSTATSTG_Release(penum);
2331
2332     *ppenum = (IEnumSTATPROPSETSTG*) enumx;
2333
2334     return S_OK;
2335 }
2336
2337 /************************************************************************
2338  * Implement IEnumSTATPROPSTG using enumx
2339  */
2340 static HRESULT WINAPI IEnumSTATPROPSTG_fnQueryInterface(
2341     IEnumSTATPROPSTG *iface,
2342     REFIID riid,
2343     void** ppvObject)
2344 {
2345     return enumx_QueryInterface((enumx_impl*)iface, riid, ppvObject);
2346 }
2347
2348 static ULONG WINAPI IEnumSTATPROPSTG_fnAddRef(
2349     IEnumSTATPROPSTG *iface)
2350 {
2351     return enumx_AddRef((enumx_impl*)iface);
2352 }
2353
2354 static ULONG WINAPI IEnumSTATPROPSTG_fnRelease(
2355     IEnumSTATPROPSTG *iface)
2356 {
2357     return enumx_Release((enumx_impl*)iface);
2358 }
2359
2360 static HRESULT WINAPI IEnumSTATPROPSTG_fnNext(
2361     IEnumSTATPROPSTG *iface,
2362     ULONG celt,
2363     STATPROPSTG *rgelt,
2364     ULONG *pceltFetched)
2365 {
2366     return enumx_Next((enumx_impl*)iface, celt, rgelt, pceltFetched);
2367 }
2368
2369 static HRESULT WINAPI IEnumSTATPROPSTG_fnSkip(
2370     IEnumSTATPROPSTG *iface,
2371     ULONG celt)
2372 {
2373     return enumx_Skip((enumx_impl*)iface, celt);
2374 }
2375
2376 static HRESULT WINAPI IEnumSTATPROPSTG_fnReset(
2377     IEnumSTATPROPSTG *iface)
2378 {
2379     return enumx_Reset((enumx_impl*)iface);
2380 }
2381
2382 static HRESULT WINAPI IEnumSTATPROPSTG_fnClone(
2383     IEnumSTATPROPSTG *iface,
2384     IEnumSTATPROPSTG **ppenum)
2385 {
2386     return enumx_Clone((enumx_impl*)iface, (enumx_impl**)ppenum);
2387 }
2388
2389 static BOOL prop_enum_stat(const void *k, const void *v, void *extra, void *arg)
2390 {
2391     enumx_impl *enumx = arg;
2392     PROPID propid = (PROPID) k;
2393     const PROPVARIANT *prop = v;
2394     STATPROPSTG stat;
2395
2396     stat.lpwstrName = NULL;
2397     stat.propid = propid;
2398     stat.vt = prop->vt;
2399
2400     enumx_add_element(enumx, &stat);
2401
2402     return TRUE;
2403 }
2404
2405 static HRESULT create_EnumSTATPROPSTG(
2406     PropertyStorage_impl *This,
2407     IEnumSTATPROPSTG** ppenum)
2408 {
2409     enumx_impl *enumx;
2410
2411     TRACE("%p %p\n", This, ppenum);
2412
2413     enumx = enumx_allocate(&IID_IEnumSTATPROPSTG,
2414                            &IEnumSTATPROPSTG_Vtbl,
2415                            sizeof (STATPROPSTG));
2416
2417     dictionary_enumerate(This->propid_to_prop, prop_enum_stat, enumx);
2418
2419     *ppenum = (IEnumSTATPROPSTG*) enumx;
2420
2421     return S_OK;
2422 }
2423
2424 /***********************************************************************
2425  * vtables
2426  */
2427 const IPropertySetStorageVtbl IPropertySetStorage_Vtbl =
2428 {
2429     IPropertySetStorage_fnQueryInterface,
2430     IPropertySetStorage_fnAddRef,
2431     IPropertySetStorage_fnRelease,
2432     IPropertySetStorage_fnCreate,
2433     IPropertySetStorage_fnOpen,
2434     IPropertySetStorage_fnDelete,
2435     IPropertySetStorage_fnEnum
2436 };
2437
2438 static const IPropertyStorageVtbl IPropertyStorage_Vtbl =
2439 {
2440     IPropertyStorage_fnQueryInterface,
2441     IPropertyStorage_fnAddRef,
2442     IPropertyStorage_fnRelease,
2443     IPropertyStorage_fnReadMultiple,
2444     IPropertyStorage_fnWriteMultiple,
2445     IPropertyStorage_fnDeleteMultiple,
2446     IPropertyStorage_fnReadPropertyNames,
2447     IPropertyStorage_fnWritePropertyNames,
2448     IPropertyStorage_fnDeletePropertyNames,
2449     IPropertyStorage_fnCommit,
2450     IPropertyStorage_fnRevert,
2451     IPropertyStorage_fnEnum,
2452     IPropertyStorage_fnSetTimes,
2453     IPropertyStorage_fnSetClass,
2454     IPropertyStorage_fnStat,
2455 };
2456
2457 static const IEnumSTATPROPSETSTGVtbl IEnumSTATPROPSETSTG_Vtbl =
2458 {
2459     IEnumSTATPROPSETSTG_fnQueryInterface,
2460     IEnumSTATPROPSETSTG_fnAddRef,
2461     IEnumSTATPROPSETSTG_fnRelease,
2462     IEnumSTATPROPSETSTG_fnNext,
2463     IEnumSTATPROPSETSTG_fnSkip,
2464     IEnumSTATPROPSETSTG_fnReset,
2465     IEnumSTATPROPSETSTG_fnClone,
2466 };
2467
2468 static const IEnumSTATPROPSTGVtbl IEnumSTATPROPSTG_Vtbl =
2469 {
2470     IEnumSTATPROPSTG_fnQueryInterface,
2471     IEnumSTATPROPSTG_fnAddRef,
2472     IEnumSTATPROPSTG_fnRelease,
2473     IEnumSTATPROPSTG_fnNext,
2474     IEnumSTATPROPSTG_fnSkip,
2475     IEnumSTATPROPSTG_fnReset,
2476     IEnumSTATPROPSTG_fnClone,
2477 };
2478
2479 /***********************************************************************
2480  * Format ID <-> name conversion
2481  */
2482 static const WCHAR szSummaryInfo[] = { 5,'S','u','m','m','a','r','y',
2483  'I','n','f','o','r','m','a','t','i','o','n',0 };
2484 static const WCHAR szDocSummaryInfo[] = { 5,'D','o','c','u','m','e','n','t',
2485  'S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',0 };
2486
2487 #define BITS_PER_BYTE    8
2488 #define CHARMASK         0x1f
2489 #define BITS_IN_CHARMASK 5
2490 #define NUM_ALPHA_CHARS  26
2491
2492 /***********************************************************************
2493  * FmtIdToPropStgName                                   [ole32.@]
2494  * Returns the storage name of the format ID rfmtid.
2495  * PARAMS
2496  *  rfmtid [I] Format ID for which to return a storage name
2497  *  str    [O] Storage name associated with rfmtid.
2498  *
2499  * RETURNS
2500  *  E_INVALIDARG if rfmtid or str i NULL, S_OK otherwise.
2501  *
2502  * NOTES
2503  * str must be at least CCH_MAX_PROPSTG_NAME characters in length.
2504  * Based on the algorithm described here:
2505  * http://msdn.microsoft.com/library/en-us/stg/stg/names_in_istorage.asp
2506  */
2507 HRESULT WINAPI FmtIdToPropStgName(const FMTID *rfmtid, LPOLESTR str)
2508 {
2509     static const char fmtMap[] = "abcdefghijklmnopqrstuvwxyz012345";
2510
2511     TRACE("%s, %p\n", debugstr_guid(rfmtid), str);
2512
2513     if (!rfmtid) return E_INVALIDARG;
2514     if (!str) return E_INVALIDARG;
2515
2516     if (IsEqualGUID(&FMTID_SummaryInformation, rfmtid))
2517         lstrcpyW(str, szSummaryInfo);
2518     else if (IsEqualGUID(&FMTID_DocSummaryInformation, rfmtid))
2519         lstrcpyW(str, szDocSummaryInfo);
2520     else if (IsEqualGUID(&FMTID_UserDefinedProperties, rfmtid))
2521         lstrcpyW(str, szDocSummaryInfo);
2522     else
2523     {
2524         BYTE *fmtptr;
2525         WCHAR *pstr = str;
2526         ULONG bitsRemaining = BITS_PER_BYTE;
2527
2528         *pstr++ = 5;
2529         for (fmtptr = (BYTE *)rfmtid; fmtptr < (BYTE *)rfmtid + sizeof(FMTID); )
2530         {
2531             ULONG i = *fmtptr >> (BITS_PER_BYTE - bitsRemaining);
2532
2533             if (bitsRemaining >= BITS_IN_CHARMASK)
2534             {
2535                 *pstr = (WCHAR)(fmtMap[i & CHARMASK]);
2536                 if (bitsRemaining == BITS_PER_BYTE && *pstr >= 'a' &&
2537                  *pstr <= 'z')
2538                     *pstr += 'A' - 'a';
2539                 pstr++;
2540                 bitsRemaining -= BITS_IN_CHARMASK;
2541                 if (bitsRemaining == 0)
2542                 {
2543                     fmtptr++;
2544                     bitsRemaining = BITS_PER_BYTE;
2545                 }
2546             }
2547             else
2548             {
2549                 if (++fmtptr < (const BYTE *)rfmtid + sizeof(FMTID))
2550                     i |= *fmtptr << bitsRemaining;
2551                 *pstr++ = (WCHAR)(fmtMap[i & CHARMASK]);
2552                 bitsRemaining += BITS_PER_BYTE - BITS_IN_CHARMASK;
2553             }
2554         }
2555         *pstr = 0;
2556     }
2557     TRACE("returning %s\n", debugstr_w(str));
2558     return S_OK;
2559 }
2560
2561 /***********************************************************************
2562  * PropStgNameToFmtId                                   [ole32.@]
2563  * Returns the format ID corresponding to the given name.
2564  * PARAMS
2565  *  str    [I] Storage name to convert to a format ID.
2566  *  rfmtid [O] Format ID corresponding to str.
2567  *
2568  * RETURNS
2569  *  E_INVALIDARG if rfmtid or str is NULL or if str can't be converted to
2570  *  a format ID, S_OK otherwise.
2571  *
2572  * NOTES
2573  * Based on the algorithm described here:
2574  * http://msdn.microsoft.com/library/en-us/stg/stg/names_in_istorage.asp
2575  */
2576 HRESULT WINAPI PropStgNameToFmtId(const LPOLESTR str, FMTID *rfmtid)
2577 {
2578     HRESULT hr = STG_E_INVALIDNAME;
2579
2580     TRACE("%s, %p\n", debugstr_w(str), rfmtid);
2581
2582     if (!rfmtid) return E_INVALIDARG;
2583     if (!str) return STG_E_INVALIDNAME;
2584
2585     if (!lstrcmpiW(str, szDocSummaryInfo))
2586     {
2587         memcpy(rfmtid, &FMTID_DocSummaryInformation, sizeof(*rfmtid));
2588         hr = S_OK;
2589     }
2590     else if (!lstrcmpiW(str, szSummaryInfo))
2591     {
2592         memcpy(rfmtid, &FMTID_SummaryInformation, sizeof(*rfmtid));
2593         hr = S_OK;
2594     }
2595     else
2596     {
2597         ULONG bits;
2598         BYTE *fmtptr = (BYTE *)rfmtid - 1;
2599         const WCHAR *pstr = str;
2600
2601         memset(rfmtid, 0, sizeof(*rfmtid));
2602         for (bits = 0; bits < sizeof(FMTID) * BITS_PER_BYTE;
2603          bits += BITS_IN_CHARMASK)
2604         {
2605             ULONG bitsUsed = bits % BITS_PER_BYTE, bitsStored;
2606             WCHAR wc;
2607
2608             if (bitsUsed == 0)
2609                 fmtptr++;
2610             wc = *++pstr - 'A';
2611             if (wc > NUM_ALPHA_CHARS)
2612             {
2613                 wc += 'A' - 'a';
2614                 if (wc > NUM_ALPHA_CHARS)
2615                 {
2616                     wc += 'a' - '0' + NUM_ALPHA_CHARS;
2617                     if (wc > CHARMASK)
2618                     {
2619                         WARN("invalid character (%d)\n", *pstr);
2620                         goto end;
2621                     }
2622                 }
2623             }
2624             *fmtptr |= wc << bitsUsed;
2625             bitsStored = min(BITS_PER_BYTE - bitsUsed, BITS_IN_CHARMASK);
2626             if (bitsStored < BITS_IN_CHARMASK)
2627             {
2628                 wc >>= BITS_PER_BYTE - bitsUsed;
2629                 if (bits + bitsStored == sizeof(FMTID) * BITS_PER_BYTE)
2630                 {
2631                     if (wc != 0)
2632                     {
2633                         WARN("extra bits\n");
2634                         goto end;
2635                     }
2636                     break;
2637                 }
2638                 fmtptr++;
2639                 *fmtptr |= (BYTE)wc;
2640             }
2641         }
2642         hr = S_OK;
2643     }
2644 end:
2645     return hr;
2646 }