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