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