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

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