?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Implement MediaQueryList's matches prop.
[wine.git] / dlls / ole32 / stg_prop.c
blob8efb8ed55436769ffe890f08e265d06f9c034bf5
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 * Copyright 2006 Mike McCormack
14 *
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 *
29 * TODO:
30 * - I don't honor the maximum property set size.
31 * - Certain bogus files could result in reading past the end of a buffer.
32 * - Mac-generated files won't be read correctly, even if they're little
33 * endian, because I disregard whether the generator was a Mac. This means
34 * strings will probably be munged (as I don't understand Mac scripts.)
35 * - Not all PROPVARIANT types are supported.
36 * - User defined properties are not supported, see comment in
37 * PropertyStorage_ReadFromStream
38 */
39
40 #include <assert.h>
41 #include <stdarg.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45
46 #define COBJMACROS
47 #define NONAMELESSUNION
48
49 #include "windef.h"
50 #include "winbase.h"
51 #include "winnls.h"
52 #include "winuser.h"
53 #include "wine/asm.h"
54 #include "wine/debug.h"
55 #include "wine/heap.h"
56 #include "dictionary.h"
57 #include "storage32.h"
58 #include "oleauto.h"
59
60 WINE_DEFAULT_DEBUG_CHANNEL(storage);
61
62 static inline StorageImpl *impl_from_IPropertySetStorage( IPropertySetStorage *iface )
63 {
64 return CONTAINING_RECORD(iface, StorageImpl, base.IPropertySetStorage_iface);
65 }
66
67 /* These are documented in MSDN,
68 * but they don't seem to be in any header file.
69 */
70 #define PROPSETHDR_BYTEORDER_MAGIC 0xfffe
71 #define PROPSETHDR_OSVER_KIND_WIN16 0
72 #define PROPSETHDR_OSVER_KIND_MAC 1
73 #define PROPSETHDR_OSVER_KIND_WIN32 2
74
75 #define CP_UNICODE 1200
76
77 #define MAX_VERSION_0_PROP_NAME_LENGTH 256
78
79 #define CFTAG_WINDOWS (-1L)
80 #define CFTAG_MACINTOSH (-2L)
81 #define CFTAG_FMTID (-3L)
82 #define CFTAG_NODATA 0L
83
84 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
85
86 typedef struct tagPROPERTYSETHEADER
87 {
88 WORD wByteOrder; /* always 0xfffe */
89 WORD wFormat; /* can be zero or one */
90 DWORD dwOSVer; /* OS version of originating system */
91 CLSID clsid; /* application CLSID */
92 DWORD reserved; /* always 1 */
93 } PROPERTYSETHEADER;
94
95 typedef struct tagFORMATIDOFFSET
96 {
97 FMTID fmtid;
98 DWORD dwOffset; /* from beginning of stream */
99 } FORMATIDOFFSET;
100
101 typedef struct tagPROPERTYSECTIONHEADER
102 {
103 DWORD cbSection;
104 DWORD cProperties;
105 } PROPERTYSECTIONHEADER;
106
107 typedef struct tagPROPERTYIDOFFSET
108 {
109 DWORD propid;
110 DWORD dwOffset; /* from beginning of section */
111 } PROPERTYIDOFFSET;
112
113 typedef struct tagPropertyStorage_impl PropertyStorage_impl;
114
115 /* Initializes the property storage from the stream (and undoes any uncommitted
116 * changes in the process.) Returns an error if there is an error reading or
117 * if the stream format doesn't match what's expected.
118 */
119 static HRESULT PropertyStorage_ReadFromStream(PropertyStorage_impl *);
120
121 static HRESULT PropertyStorage_WriteToStream(PropertyStorage_impl *);
122
123 /* Creates the dictionaries used by the property storage. If successful, all
124 * the dictionaries have been created. If failed, none has been. (This makes
125 * it a bit easier to deal with destroying them.)
126 */
127 static HRESULT PropertyStorage_CreateDictionaries(PropertyStorage_impl *);
128
129 static void PropertyStorage_DestroyDictionaries(PropertyStorage_impl *);
130
131 /* Copies from propvar to prop. If propvar's type is VT_LPSTR, copies the
132 * string using PropertyStorage_StringCopy.
133 */
134 static HRESULT PropertyStorage_PropVariantCopy(PROPVARIANT *prop,
135 const PROPVARIANT *propvar, UINT targetCP, UINT srcCP);
136
137 /* Copies the string src, which is encoded using code page srcCP, and returns
138 * it in *dst, in the code page specified by targetCP. The returned string is
139 * allocated using CoTaskMemAlloc.
140 * If srcCP is CP_UNICODE, src is in fact an LPCWSTR. Similarly, if targetCP
141 * is CP_UNICODE, the returned string is in fact an LPWSTR.
142 * Returns S_OK on success, something else on failure.
143 */
144 static HRESULT PropertyStorage_StringCopy(LPCSTR src, UINT srcCP, LPSTR *dst,
145 UINT targetCP);
146
147 static const IPropertyStorageVtbl IPropertyStorage_Vtbl;
148
149 /***********************************************************************
150 * Implementation of IPropertyStorage
151 */
152 struct tagPropertyStorage_impl
153 {
154 IPropertyStorage IPropertyStorage_iface;
155 LONG ref;
156 CRITICAL_SECTION cs;
157 IStream *stm;
158 BOOL dirty;
159 FMTID fmtid;
160 CLSID clsid;
161 WORD format;
162 DWORD originatorOS;
163 DWORD grfFlags;
164 DWORD grfMode;
165 UINT codePage;
166 LCID locale;
167 PROPID highestProp;
168 struct dictionary *name_to_propid;
169 struct dictionary *propid_to_name;
170 struct dictionary *propid_to_prop;
171 };
172
173 static inline PropertyStorage_impl *impl_from_IPropertyStorage(IPropertyStorage *iface)
174 {
175 return CONTAINING_RECORD(iface, PropertyStorage_impl, IPropertyStorage_iface);
176 }
177
178 struct enum_stat_prop_stg
179 {
180 IEnumSTATPROPSTG IEnumSTATPROPSTG_iface;
181 LONG refcount;
182 PropertyStorage_impl *storage;
183 STATPROPSTG *stats;
184 size_t current;
185 size_t count;
186 };
187
188 static struct enum_stat_prop_stg *impl_from_IEnumSTATPROPSTG(IEnumSTATPROPSTG *iface)
189 {
190 return CONTAINING_RECORD(iface, struct enum_stat_prop_stg, IEnumSTATPROPSTG_iface);
191 }
192
193 static HRESULT WINAPI enum_stat_prop_stg_QueryInterface(IEnumSTATPROPSTG *iface, REFIID riid, void **obj)
194 {
195 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
196
197 if (IsEqualIID(riid, &IID_IEnumSTATPROPSTG) ||
198 IsEqualIID(riid, &IID_IUnknown))
199 {
200 *obj = iface;
201 IEnumSTATPROPSTG_AddRef(iface);
202 return S_OK;
203 }
204
205 WARN("Unsupported interface %s.\n", debugstr_guid(riid));
206 return E_NOINTERFACE;
207 }
208
209 static ULONG WINAPI enum_stat_prop_stg_AddRef(IEnumSTATPROPSTG *iface)
210 {
211 struct enum_stat_prop_stg *penum = impl_from_IEnumSTATPROPSTG(iface);
212 LONG refcount = InterlockedIncrement(&penum->refcount);
213
214 TRACE("%p, refcount %lu.\n", iface, refcount);
215
216 return refcount;
217 }
218
219 static ULONG WINAPI enum_stat_prop_stg_Release(IEnumSTATPROPSTG *iface)
220 {
221 struct enum_stat_prop_stg *penum = impl_from_IEnumSTATPROPSTG(iface);
222 LONG refcount = InterlockedDecrement(&penum->refcount);
223
224 TRACE("%p, refcount %lu.\n", iface, refcount);
225
226 if (!refcount)
227 {
228 IPropertyStorage_Release(&penum->storage->IPropertyStorage_iface);
229 heap_free(penum->stats);
230 heap_free(penum);
231 }
232
233 return refcount;
234 }
235
236 static HRESULT WINAPI enum_stat_prop_stg_Next(IEnumSTATPROPSTG *iface, ULONG celt, STATPROPSTG *ret, ULONG *fetched)
237 {
238 struct enum_stat_prop_stg *penum = impl_from_IEnumSTATPROPSTG(iface);
239 ULONG count = 0;
240 WCHAR *name;
241
242 TRACE("%p, %lu, %p, %p.\n", iface, celt, ret, fetched);
243
244 if (penum->current == ~0u)
245 penum->current = 0;
246
247 while (count < celt && penum->current < penum->count)
248 {
249 *ret = penum->stats[penum->current++];
250
251 if (dictionary_find(penum->storage->propid_to_name, UlongToPtr(ret->propid), (void **)&name))
252 {
253 SIZE_T size = (lstrlenW(name) + 1) * sizeof(WCHAR);
254 ret->lpwstrName = CoTaskMemAlloc(size);
255 if (ret->lpwstrName)
256 memcpy(ret->lpwstrName, name, size);
257 }
258 ret++;
259 count++;
260 }
261
262 if (fetched)
263 *fetched = count;
264
265 return count < celt ? S_FALSE : S_OK;
266 }
267
268 static HRESULT WINAPI enum_stat_prop_stg_Skip(IEnumSTATPROPSTG *iface, ULONG celt)
269 {
270 FIXME("%p, %lu.\n", iface, celt);
271
272 return S_OK;
273 }
274
275 static HRESULT WINAPI enum_stat_prop_stg_Reset(IEnumSTATPROPSTG *iface)
276 {
277 struct enum_stat_prop_stg *penum = impl_from_IEnumSTATPROPSTG(iface);
278
279 TRACE("%p.\n", iface);
280
281 penum->current = ~0u;
282
283 return S_OK;
284 }
285
286 static HRESULT WINAPI enum_stat_prop_stg_Clone(IEnumSTATPROPSTG *iface, IEnumSTATPROPSTG **ppenum)
287 {
288 FIXME("%p, %p.\n", iface, ppenum);
289
290 return E_NOTIMPL;
291 }
292
293 static const IEnumSTATPROPSTGVtbl enum_stat_prop_stg_vtbl =
294 {
295 enum_stat_prop_stg_QueryInterface,
296 enum_stat_prop_stg_AddRef,
297 enum_stat_prop_stg_Release,
298 enum_stat_prop_stg_Next,
299 enum_stat_prop_stg_Skip,
300 enum_stat_prop_stg_Reset,
301 enum_stat_prop_stg_Clone,
302 };
303
304 static BOOL prop_enum_stat(const void *k, const void *v, void *extra, void *arg)
305 {
306 struct enum_stat_prop_stg *stg = arg;
307 PROPID propid = PtrToUlong(k);
308 const PROPVARIANT *prop = v;
309 STATPROPSTG *dest;
310
311 dest = &stg->stats[stg->count];
312
313 dest->lpwstrName = NULL;
314 dest->propid = propid;
315 dest->vt = prop->vt;
316 stg->count++;
317
318 return TRUE;
319 }
320
321 static BOOL prop_enum_stat_count(const void *k, const void *v, void *extra, void *arg)
322 {
323 DWORD *count = arg;
324
325 *count += 1;
326
327 return TRUE;
328 }
329
330 static HRESULT create_enum_stat_prop_stg(PropertyStorage_impl *storage, IEnumSTATPROPSTG **ret)
331 {
332 struct enum_stat_prop_stg *enum_obj;
333 DWORD count;
334
335 enum_obj = heap_alloc_zero(sizeof(*enum_obj));
336 if (!enum_obj)
337 return E_OUTOFMEMORY;
338
339 enum_obj->IEnumSTATPROPSTG_iface.lpVtbl = &enum_stat_prop_stg_vtbl;
340 enum_obj->refcount = 1;
341 enum_obj->storage = storage;
342 IPropertyStorage_AddRef(&storage->IPropertyStorage_iface);
343
344 count = 0;
345 dictionary_enumerate(storage->propid_to_prop, prop_enum_stat_count, &count);
346
347 if (count)
348 {
349 if (!(enum_obj->stats = heap_alloc(sizeof(*enum_obj->stats) * count)))
350 {
351 IEnumSTATPROPSTG_Release(&enum_obj->IEnumSTATPROPSTG_iface);
352 return E_OUTOFMEMORY;
353 }
354
355 dictionary_enumerate(storage->propid_to_prop, prop_enum_stat, enum_obj);
356 }
357
358 *ret = &enum_obj->IEnumSTATPROPSTG_iface;
359
360 return S_OK;
361 }
362
363 /************************************************************************
364 * IPropertyStorage_fnQueryInterface (IPropertyStorage)
365 */
366 static HRESULT WINAPI IPropertyStorage_fnQueryInterface(
367 IPropertyStorage *iface,
368 REFIID riid,
369 void** ppvObject)
370 {
371 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
372
373 TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppvObject);
374
375 if (!ppvObject)
376 return E_INVALIDARG;
377
378 *ppvObject = 0;
379
380 if (IsEqualGUID(&IID_IUnknown, riid) ||
381 IsEqualGUID(&IID_IPropertyStorage, riid))
382 {
383 IPropertyStorage_AddRef(iface);
384 *ppvObject = iface;
385 return S_OK;
386 }
387
388 return E_NOINTERFACE;
389 }
390
391 /************************************************************************
392 * IPropertyStorage_fnAddRef (IPropertyStorage)
393 */
394 static ULONG WINAPI IPropertyStorage_fnAddRef(
395 IPropertyStorage *iface)
396 {
397 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
398 return InterlockedIncrement(&This->ref);
399 }
400
401 /************************************************************************
402 * IPropertyStorage_fnRelease (IPropertyStorage)
403 */
404 static ULONG WINAPI IPropertyStorage_fnRelease(
405 IPropertyStorage *iface)
406 {
407 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
408 ULONG ref;
409
410 ref = InterlockedDecrement(&This->ref);
411 if (ref == 0)
412 {
413 TRACE("Destroying %p\n", This);
414 if (This->dirty)
415 IPropertyStorage_Commit(iface, STGC_DEFAULT);
416 IStream_Release(This->stm);
417 This->cs.DebugInfo->Spare[0] = 0;
418 DeleteCriticalSection(&This->cs);
419 PropertyStorage_DestroyDictionaries(This);
420 HeapFree(GetProcessHeap(), 0, This);
421 }
422 return ref;
423 }
424
425 static PROPVARIANT *PropertyStorage_FindProperty(PropertyStorage_impl *This,
426 DWORD propid)
427 {
428 PROPVARIANT *ret = NULL;
429
430 dictionary_find(This->propid_to_prop, UlongToPtr(propid), (void **)&ret);
431 TRACE("returning %p\n", ret);
432 return ret;
433 }
434
435 /* Returns NULL if name is NULL. */
436 static PROPVARIANT *PropertyStorage_FindPropertyByName(
437 PropertyStorage_impl *This, LPCWSTR name)
438 {
439 PROPVARIANT *ret = NULL;
440 void *propid;
441
442 if (!name)
443 return NULL;
444 if (This->codePage == CP_UNICODE)
445 {
446 if (dictionary_find(This->name_to_propid, name, &propid))
447 ret = PropertyStorage_FindProperty(This, PtrToUlong(propid));
448 }
449 else
450 {
451 LPSTR ansiName;
452 HRESULT hr = PropertyStorage_StringCopy((LPCSTR)name, CP_UNICODE,
453 &ansiName, This->codePage);
454
455 if (SUCCEEDED(hr))
456 {
457 if (dictionary_find(This->name_to_propid, ansiName, &propid))
458 ret = PropertyStorage_FindProperty(This, PtrToUlong(propid));
459 CoTaskMemFree(ansiName);
460 }
461 }
462 TRACE("returning %p\n", ret);
463 return ret;
464 }
465
466 static LPWSTR PropertyStorage_FindPropertyNameById(PropertyStorage_impl *This,
467 DWORD propid)
468 {
469 LPWSTR ret = NULL;
470
471 dictionary_find(This->propid_to_name, UlongToPtr(propid), (void **)&ret);
472 TRACE("returning %p\n", ret);
473 return ret;
474 }
475
476 /************************************************************************
477 * IPropertyStorage_fnReadMultiple (IPropertyStorage)
478 */
479 static HRESULT WINAPI IPropertyStorage_fnReadMultiple(
480 IPropertyStorage* iface,
481 ULONG cpspec,
482 const PROPSPEC rgpspec[],
483 PROPVARIANT rgpropvar[])
484 {
485 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
486 HRESULT hr = S_OK;
487 ULONG i;
488
489 TRACE("%p, %lu, %p, %p\n", iface, cpspec, rgpspec, rgpropvar);
490
491 if (!cpspec)
492 return S_FALSE;
493 if (!rgpspec || !rgpropvar)
494 return E_INVALIDARG;
495 EnterCriticalSection(&This->cs);
496 for (i = 0; i < cpspec; i++)
497 {
498 PropVariantInit(&rgpropvar[i]);
499 if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
500 {
501 PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
502 rgpspec[i].u.lpwstr);
503
504 if (prop)
505 PropertyStorage_PropVariantCopy(&rgpropvar[i], prop, GetACP(),
506 This->codePage);
507 }
508 else
509 {
510 switch (rgpspec[i].u.propid)
511 {
512 case PID_CODEPAGE:
513 rgpropvar[i].vt = VT_I2;
514 rgpropvar[i].iVal = This->codePage;
515 break;
516 case PID_LOCALE:
517 rgpropvar[i].vt = VT_I4;
518 rgpropvar[i].lVal = This->locale;
519 break;
520 default:
521 {
522 PROPVARIANT *prop = PropertyStorage_FindProperty(This,
523 rgpspec[i].u.propid);
524
525 if (prop)
526 PropertyStorage_PropVariantCopy(&rgpropvar[i], prop,
527 GetACP(), This->codePage);
528 else
529 hr = S_FALSE;
530 }
531 }
532 }
533 }
534 LeaveCriticalSection(&This->cs);
535 return hr;
536 }
537
538 static HRESULT PropertyStorage_StringCopy(LPCSTR src, UINT srcCP, LPSTR *dst, UINT dstCP)
539 {
540 HRESULT hr = S_OK;
541 int len;
542
543 TRACE("%s, %p, %d, %d\n",
544 srcCP == CP_UNICODE ? debugstr_w((LPCWSTR)src) : debugstr_a(src), dst,
545 dstCP, srcCP);
546 assert(src);
547 assert(dst);
548 *dst = NULL;
549 if (dstCP == srcCP)
550 {
551 size_t len;
552
553 if (dstCP == CP_UNICODE)
554 len = (lstrlenW((LPCWSTR)src) + 1) * sizeof(WCHAR);
555 else
556 len = strlen(src) + 1;
557 *dst = CoTaskMemAlloc(len);
558 if (!*dst)
559 hr = STG_E_INSUFFICIENTMEMORY;
560 else
561 memcpy(*dst, src, len);
562 }
563 else
564 {
565 if (dstCP == CP_UNICODE)
566 {
567 len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
568 *dst = CoTaskMemAlloc(len * sizeof(WCHAR));
569 if (!*dst)
570 hr = STG_E_INSUFFICIENTMEMORY;
571 else
572 MultiByteToWideChar(srcCP, 0, src, -1, (LPWSTR)*dst, len);
573 }
574 else
575 {
576 LPCWSTR wideStr = NULL;
577 LPWSTR wideStr_tmp = NULL;
578
579 if (srcCP == CP_UNICODE)
580 wideStr = (LPCWSTR)src;
581 else
582 {
583 len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
584 wideStr_tmp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
585 if (wideStr_tmp)
586 {
587 MultiByteToWideChar(srcCP, 0, src, -1, wideStr_tmp, len);
588 wideStr = wideStr_tmp;
589 }
590 else
591 hr = STG_E_INSUFFICIENTMEMORY;
592 }
593 if (SUCCEEDED(hr))
594 {
595 len = WideCharToMultiByte(dstCP, 0, wideStr, -1, NULL, 0,
596 NULL, NULL);
597 *dst = CoTaskMemAlloc(len);
598 if (!*dst)
599 hr = STG_E_INSUFFICIENTMEMORY;
600 else
601 {
602 BOOL defCharUsed = FALSE;
603
604 if (WideCharToMultiByte(dstCP, 0, wideStr, -1, *dst, len,
605 NULL, &defCharUsed) == 0 || defCharUsed)
606 {
607 CoTaskMemFree(*dst);
608 *dst = NULL;
609 hr = HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION);
610 }
611 }
612 }
613 HeapFree(GetProcessHeap(), 0, wideStr_tmp);
614 }
615 }
616 TRACE("returning %#lx (%s)\n", hr,
617 dstCP == CP_UNICODE ? debugstr_w((LPCWSTR)*dst) : debugstr_a(*dst));
618 return hr;
619 }
620
621 static HRESULT PropertyStorage_PropVariantCopy(PROPVARIANT *prop, const PROPVARIANT *propvar,
622 UINT targetCP, UINT srcCP)
623 {
624 HRESULT hr = S_OK;
625
626 assert(prop);
627 assert(propvar);
628
629 switch (propvar->vt)
630 {
631 case VT_LPSTR:
632 hr = PropertyStorage_StringCopy(propvar->pszVal, srcCP, &prop->pszVal, targetCP);
633 if (SUCCEEDED(hr))
634 prop->vt = VT_LPSTR;
635 break;
636 case VT_BSTR:
637 if ((prop->bstrVal = SysAllocStringLen(propvar->bstrVal, SysStringLen(propvar->bstrVal))))
638 prop->vt = VT_BSTR;
639 else
640 hr = E_OUTOFMEMORY;
641 break;
642 default:
643 hr = PropVariantCopy(prop, propvar);
644 }
645
646 return hr;
647 }
648
649 /* Stores the property with id propid and value propvar into this property
650 * storage. lcid is ignored if propvar's type is not VT_LPSTR. If propvar's
651 * type is VT_LPSTR, converts the string using lcid as the source code page
652 * and This->codePage as the target code page before storing.
653 * As a side effect, may change This->format to 1 if the type of propvar is
654 * a version 1-only property.
655 */
656 static HRESULT PropertyStorage_StorePropWithId(PropertyStorage_impl *This,
657 PROPID propid, const PROPVARIANT *propvar, UINT cp)
658 {
659 HRESULT hr = S_OK;
660 PROPVARIANT *prop = PropertyStorage_FindProperty(This, propid);
661
662 assert(propvar);
663 if (propvar->vt & VT_BYREF || propvar->vt & VT_ARRAY)
664 This->format = 1;
665 switch (propvar->vt)
666 {
667 case VT_DECIMAL:
668 case VT_I1:
669 case VT_INT:
670 case VT_UINT:
671 case VT_VECTOR|VT_I1:
672 This->format = 1;
673 }
674 TRACE("Setting %#lx to type %d\n", propid, propvar->vt);
675 if (prop)
676 {
677 PropVariantClear(prop);
678 hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage, cp);
679 }
680 else
681 {
682 prop = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
683 sizeof(PROPVARIANT));
684 if (prop)
685 {
686 hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage, cp);
687 if (SUCCEEDED(hr))
688 {
689 dictionary_insert(This->propid_to_prop, UlongToPtr(propid), prop);
690 if (propid > This->highestProp)
691 This->highestProp = propid;
692 }
693 else
694 HeapFree(GetProcessHeap(), 0, prop);
695 }
696 else
697 hr = STG_E_INSUFFICIENTMEMORY;
698 }
699 return hr;
700 }
701
702 /* Adds the name srcName to the name dictionaries, mapped to property ID id.
703 * srcName is encoded in code page cp, and is converted to This->codePage.
704 * If cp is CP_UNICODE, srcName is actually a unicode string.
705 * As a side effect, may change This->format to 1 if srcName is too long for
706 * a version 0 property storage.
707 * Doesn't validate id.
708 */
709 static HRESULT PropertyStorage_StoreNameWithId(PropertyStorage_impl *This,
710 LPCSTR srcName, UINT cp, PROPID id)
711 {
712 LPSTR name;
713 HRESULT hr;
714
715 assert(srcName);
716
717 hr = PropertyStorage_StringCopy(srcName, cp, &name, This->codePage);
718 if (SUCCEEDED(hr))
719 {
720 if (This->codePage == CP_UNICODE)
721 {
722 if (lstrlenW((LPWSTR)name) >= MAX_VERSION_0_PROP_NAME_LENGTH)
723 This->format = 1;
724 }
725 else
726 {
727 if (strlen(name) >= MAX_VERSION_0_PROP_NAME_LENGTH)
728 This->format = 1;
729 }
730 TRACE("Adding prop name %s, propid %ld\n",
731 This->codePage == CP_UNICODE ? debugstr_w((LPCWSTR)name) :
732 debugstr_a(name), id);
733 dictionary_insert(This->name_to_propid, name, UlongToPtr(id));
734 dictionary_insert(This->propid_to_name, UlongToPtr(id), name);
735 }
736 return hr;
737 }
738
739 /************************************************************************
740 * IPropertyStorage_fnWriteMultiple (IPropertyStorage)
741 */
742 static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
743 IPropertyStorage* iface,
744 ULONG cpspec,
745 const PROPSPEC rgpspec[],
746 const PROPVARIANT rgpropvar[],
747 PROPID propidNameFirst)
748 {
749 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
750 HRESULT hr = S_OK;
751 ULONG i;
752
753 TRACE("%p, %lu, %p, %p.\n", iface, cpspec, rgpspec, rgpropvar);
754
755 if (cpspec && (!rgpspec || !rgpropvar))
756 return E_INVALIDARG;
757 if (!(This->grfMode & STGM_READWRITE))
758 return STG_E_ACCESSDENIED;
759 EnterCriticalSection(&This->cs);
760 This->dirty = TRUE;
761 This->originatorOS = (DWORD)MAKELONG(LOWORD(GetVersion()),
762 PROPSETHDR_OSVER_KIND_WIN32) ;
763 for (i = 0; i < cpspec; i++)
764 {
765 if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
766 {
767 PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
768 rgpspec[i].u.lpwstr);
769
770 if (prop)
771 PropVariantCopy(prop, &rgpropvar[i]);
772 else
773 {
774 /* Note that I don't do the special cases here that I do below,
775 * because naming the special PIDs isn't supported.
776 */
777 if (propidNameFirst < PID_FIRST_USABLE ||
778 propidNameFirst >= PID_MIN_READONLY)
779 hr = STG_E_INVALIDPARAMETER;
780 else
781 {
782 PROPID nextId = max(propidNameFirst, This->highestProp + 1);
783
784 hr = PropertyStorage_StoreNameWithId(This,
785 (LPCSTR)rgpspec[i].u.lpwstr, CP_UNICODE, nextId);
786 if (SUCCEEDED(hr))
787 hr = PropertyStorage_StorePropWithId(This, nextId,
788 &rgpropvar[i], GetACP());
789 }
790 }
791 }
792 else
793 {
794 switch (rgpspec[i].u.propid)
795 {
796 case PID_DICTIONARY:
797 /* Can't set the dictionary */
798 hr = STG_E_INVALIDPARAMETER;
799 break;
800 case PID_CODEPAGE:
801 /* Can only set the code page if nothing else has been set */
802 if (dictionary_num_entries(This->propid_to_prop) == 0 &&
803 rgpropvar[i].vt == VT_I2)
804 {
805 This->codePage = (USHORT)rgpropvar[i].iVal;
806 if (This->codePage == CP_UNICODE)
807 This->grfFlags &= ~PROPSETFLAG_ANSI;
808 else
809 This->grfFlags |= PROPSETFLAG_ANSI;
810 }
811 else
812 hr = STG_E_INVALIDPARAMETER;
813 break;
814 case PID_LOCALE:
815 /* Can only set the locale if nothing else has been set */
816 if (dictionary_num_entries(This->propid_to_prop) == 0 &&
817 rgpropvar[i].vt == VT_I4)
818 This->locale = rgpropvar[i].lVal;
819 else
820 hr = STG_E_INVALIDPARAMETER;
821 break;
822 case PID_ILLEGAL:
823 /* silently ignore like MSDN says */
824 break;
825 default:
826 if (rgpspec[i].u.propid >= PID_MIN_READONLY)
827 hr = STG_E_INVALIDPARAMETER;
828 else
829 hr = PropertyStorage_StorePropWithId(This,
830 rgpspec[i].u.propid, &rgpropvar[i], GetACP());
831 }
832 }
833 }
834 if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
835 IPropertyStorage_Commit(iface, STGC_DEFAULT);
836 LeaveCriticalSection(&This->cs);
837 return hr;
838 }
839
840 /************************************************************************
841 * IPropertyStorage_fnDeleteMultiple (IPropertyStorage)
842 */
843 static HRESULT WINAPI IPropertyStorage_fnDeleteMultiple(
844 IPropertyStorage* iface,
845 ULONG cpspec,
846 const PROPSPEC rgpspec[])
847 {
848 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
849 ULONG i;
850 HRESULT hr;
851
852 TRACE("%p, %ld, %p.\n", iface, cpspec, rgpspec);
853
854 if (cpspec && !rgpspec)
855 return E_INVALIDARG;
856 if (!(This->grfMode & STGM_READWRITE))
857 return STG_E_ACCESSDENIED;
858 hr = S_OK;
859 EnterCriticalSection(&This->cs);
860 This->dirty = TRUE;
861 for (i = 0; i < cpspec; i++)
862 {
863 if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
864 {
865 void *propid;
866
867 if (dictionary_find(This->name_to_propid, rgpspec[i].u.lpwstr, &propid))
868 dictionary_remove(This->propid_to_prop, propid);
869 }
870 else
871 {
872 if (rgpspec[i].u.propid >= PID_FIRST_USABLE &&
873 rgpspec[i].u.propid < PID_MIN_READONLY)
874 dictionary_remove(This->propid_to_prop, UlongToPtr(rgpspec[i].u.propid));
875 else
876 hr = STG_E_INVALIDPARAMETER;
877 }
878 }
879 if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
880 IPropertyStorage_Commit(iface, STGC_DEFAULT);
881 LeaveCriticalSection(&This->cs);
882 return hr;
883 }
884
885 /************************************************************************
886 * IPropertyStorage_fnReadPropertyNames (IPropertyStorage)
887 */
888 static HRESULT WINAPI IPropertyStorage_fnReadPropertyNames(
889 IPropertyStorage* iface,
890 ULONG cpropid,
891 const PROPID rgpropid[],
892 LPOLESTR rglpwstrName[])
893 {
894 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
895 ULONG i;
896 HRESULT hr = S_FALSE;
897
898 TRACE("%p, %ld, %p, %p.\n", iface, cpropid, rgpropid, rglpwstrName);
899
900 if (cpropid && (!rgpropid || !rglpwstrName))
901 return E_INVALIDARG;
902 EnterCriticalSection(&This->cs);
903 for (i = 0; i < cpropid && SUCCEEDED(hr); i++)
904 {
905 LPWSTR name = PropertyStorage_FindPropertyNameById(This, rgpropid[i]);
906
907 if (name)
908 {
909 size_t len = lstrlenW(name);
910
911 hr = S_OK;
912 rglpwstrName[i] = CoTaskMemAlloc((len + 1) * sizeof(WCHAR));
913 if (rglpwstrName[i])
914 memcpy(rglpwstrName[i], name, (len + 1) * sizeof(WCHAR));
915 else
916 hr = STG_E_INSUFFICIENTMEMORY;
917 }
918 else
919 rglpwstrName[i] = NULL;
920 }
921 LeaveCriticalSection(&This->cs);
922 return hr;
923 }
924
925 /************************************************************************
926 * IPropertyStorage_fnWritePropertyNames (IPropertyStorage)
927 */
928 static HRESULT WINAPI IPropertyStorage_fnWritePropertyNames(
929 IPropertyStorage* iface,
930 ULONG cpropid,
931 const PROPID rgpropid[],
932 const LPOLESTR rglpwstrName[])
933 {
934 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
935 ULONG i;
936 HRESULT hr;
937
938 TRACE("%p, %lu, %p, %p.\n", iface, cpropid, rgpropid, rglpwstrName);
939
940 if (cpropid && (!rgpropid || !rglpwstrName))
941 return E_INVALIDARG;
942 if (!(This->grfMode & STGM_READWRITE))
943 return STG_E_ACCESSDENIED;
944 hr = S_OK;
945 EnterCriticalSection(&This->cs);
946 This->dirty = TRUE;
947 for (i = 0; SUCCEEDED(hr) && i < cpropid; i++)
948 {
949 if (rgpropid[i] != PID_ILLEGAL)
950 hr = PropertyStorage_StoreNameWithId(This, (LPCSTR)rglpwstrName[i],
951 CP_UNICODE, rgpropid[i]);
952 }
953 if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
954 IPropertyStorage_Commit(iface, STGC_DEFAULT);
955 LeaveCriticalSection(&This->cs);
956 return hr;
957 }
958
959 /************************************************************************
960 * IPropertyStorage_fnDeletePropertyNames (IPropertyStorage)
961 */
962 static HRESULT WINAPI IPropertyStorage_fnDeletePropertyNames(
963 IPropertyStorage* iface,
964 ULONG cpropid,
965 const PROPID rgpropid[])
966 {
967 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
968 ULONG i;
969 HRESULT hr;
970
971 TRACE("%p, %ld, %p.\n", iface, cpropid, rgpropid);
972
973 if (cpropid && !rgpropid)
974 return E_INVALIDARG;
975 if (!(This->grfMode & STGM_READWRITE))
976 return STG_E_ACCESSDENIED;
977 hr = S_OK;
978 EnterCriticalSection(&This->cs);
979 This->dirty = TRUE;
980 for (i = 0; i < cpropid; i++)
981 {
982 LPWSTR name = NULL;
983
984 if (dictionary_find(This->propid_to_name, UlongToPtr(rgpropid[i]), (void **)&name))
985 {
986 dictionary_remove(This->propid_to_name, UlongToPtr(rgpropid[i]));
987 dictionary_remove(This->name_to_propid, name);
988 }
989 }
990 if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
991 IPropertyStorage_Commit(iface, STGC_DEFAULT);
992 LeaveCriticalSection(&This->cs);
993 return hr;
994 }
995
996 /************************************************************************
997 * IPropertyStorage_fnCommit (IPropertyStorage)
998 */
999 static HRESULT WINAPI IPropertyStorage_fnCommit(
1000 IPropertyStorage* iface,
1001 DWORD grfCommitFlags)
1002 {
1003 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
1004 HRESULT hr;
1005
1006 TRACE("%p, %#lx.\n", iface, grfCommitFlags);
1007
1008 if (!(This->grfMode & STGM_READWRITE))
1009 return STG_E_ACCESSDENIED;
1010 EnterCriticalSection(&This->cs);
1011 if (This->dirty)
1012 hr = PropertyStorage_WriteToStream(This);
1013 else
1014 hr = S_OK;
1015 LeaveCriticalSection(&This->cs);
1016 return hr;
1017 }
1018
1019 /************************************************************************
1020 * IPropertyStorage_fnRevert (IPropertyStorage)
1021 */
1022 static HRESULT WINAPI IPropertyStorage_fnRevert(
1023 IPropertyStorage* iface)
1024 {
1025 HRESULT hr;
1026 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
1027
1028 TRACE("%p\n", iface);
1029
1030 EnterCriticalSection(&This->cs);
1031 if (This->dirty)
1032 {
1033 PropertyStorage_DestroyDictionaries(This);
1034 hr = PropertyStorage_CreateDictionaries(This);
1035 if (SUCCEEDED(hr))
1036 hr = PropertyStorage_ReadFromStream(This);
1037 }
1038 else
1039 hr = S_OK;
1040 LeaveCriticalSection(&This->cs);
1041 return hr;
1042 }
1043
1044 /************************************************************************
1045 * IPropertyStorage_fnEnum (IPropertyStorage)
1046 */
1047 static HRESULT WINAPI IPropertyStorage_fnEnum(IPropertyStorage *iface, IEnumSTATPROPSTG **ppenum)
1048 {
1049 PropertyStorage_impl *storage = impl_from_IPropertyStorage(iface);
1050
1051 TRACE("%p, %p.\n", iface, ppenum);
1052
1053 return create_enum_stat_prop_stg(storage, ppenum);
1054 }
1055
1056 /************************************************************************
1057 * IPropertyStorage_fnSetTimes (IPropertyStorage)
1058 */
1059 static HRESULT WINAPI IPropertyStorage_fnSetTimes(
1060 IPropertyStorage* iface,
1061 const FILETIME* pctime,
1062 const FILETIME* patime,
1063 const FILETIME* pmtime)
1064 {
1065 FIXME("\n");
1066 return E_NOTIMPL;
1067 }
1068
1069 /************************************************************************
1070 * IPropertyStorage_fnSetClass (IPropertyStorage)
1071 */
1072 static HRESULT WINAPI IPropertyStorage_fnSetClass(
1073 IPropertyStorage* iface,
1074 REFCLSID clsid)
1075 {
1076 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
1077
1078 TRACE("%p, %s\n", iface, debugstr_guid(clsid));
1079
1080 if (!clsid)
1081 return E_INVALIDARG;
1082 if (!(This->grfMode & STGM_READWRITE))
1083 return STG_E_ACCESSDENIED;
1084 This->clsid = *clsid;
1085 This->dirty = TRUE;
1086 if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
1087 IPropertyStorage_Commit(iface, STGC_DEFAULT);
1088 return S_OK;
1089 }
1090
1091 /************************************************************************
1092 * IPropertyStorage_fnStat (IPropertyStorage)
1093 */
1094 static HRESULT WINAPI IPropertyStorage_fnStat(
1095 IPropertyStorage* iface,
1096 STATPROPSETSTG* statpsstg)
1097 {
1098 PropertyStorage_impl *This = impl_from_IPropertyStorage(iface);
1099 STATSTG stat;
1100 HRESULT hr;
1101
1102 TRACE("%p, %p\n", iface, statpsstg);
1103
1104 if (!statpsstg)
1105 return E_INVALIDARG;
1106
1107 hr = IStream_Stat(This->stm, &stat, STATFLAG_NONAME);
1108 if (SUCCEEDED(hr))
1109 {
1110 statpsstg->fmtid = This->fmtid;
1111 statpsstg->clsid = This->clsid;
1112 statpsstg->grfFlags = This->grfFlags;
1113 statpsstg->mtime = stat.mtime;
1114 statpsstg->ctime = stat.ctime;
1115 statpsstg->atime = stat.atime;
1116 statpsstg->dwOSVersion = This->originatorOS;
1117 }
1118 return hr;
1119 }
1120
1121 static int PropertyStorage_PropNameCompare(const void *a, const void *b,
1122 void *extra)
1123 {
1124 PropertyStorage_impl *This = extra;
1125
1126 if (This->codePage == CP_UNICODE)
1127 {
1128 TRACE("(%s, %s)\n", debugstr_w(a), debugstr_w(b));
1129 if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
1130 return wcscmp(a, b);
1131 else
1132 return lstrcmpiW(a, b);
1133 }
1134 else
1135 {
1136 TRACE("(%s, %s)\n", debugstr_a(a), debugstr_a(b));
1137 if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
1138 return lstrcmpA(a, b);
1139 else
1140 return lstrcmpiA(a, b);
1141 }
1142 }
1143
1144 static void PropertyStorage_PropNameDestroy(void *k, void *d, void *extra)
1145 {
1146 CoTaskMemFree(k);
1147 }
1148
1149 static int PropertyStorage_PropCompare(const void *a, const void *b,
1150 void *extra)
1151 {
1152 TRACE("%lu, %lu.\n", PtrToUlong(a), PtrToUlong(b));
1153 return PtrToUlong(a) - PtrToUlong(b);
1154 }
1155
1156 static void PropertyStorage_PropertyDestroy(void *k, void *d, void *extra)
1157 {
1158 PropVariantClear(d);
1159 HeapFree(GetProcessHeap(), 0, d);
1160 }
1161
1162 #ifdef WORDS_BIGENDIAN
1163 /* Swaps each character in str to or from little endian; assumes the conversion
1164 * is symmetric, that is, that lendian16toh is equivalent to htole16.
1165 */
1166 static void PropertyStorage_ByteSwapString(LPWSTR str, size_t len)
1167 {
1168 DWORD i;
1169
1170 /* Swap characters to host order.
1171 * FIXME: alignment?
1172 */
1173 for (i = 0; i < len; i++)
1174 str[i] = lendian16toh(str[i]);
1175 }
1176 #else
1177 #define PropertyStorage_ByteSwapString(s, l)
1178 #endif
1179
1180 static void* WINAPI Allocate_CoTaskMemAlloc(void *this, ULONG size)
1181 {
1182 return CoTaskMemAlloc(size);
1183 }
1184
1185 struct read_buffer
1186 {
1187 BYTE *data;
1188 size_t size;
1189 };
1190
1191 static HRESULT buffer_test_offset(const struct read_buffer *buffer, size_t offset, size_t len)
1192 {
1193 return len > buffer->size || offset > buffer->size - len ? STG_E_READFAULT : S_OK;
1194 }
1195
1196 static HRESULT buffer_read_uint64(const struct read_buffer *buffer, size_t offset, ULARGE_INTEGER *data)
1197 {
1198 HRESULT hr;
1199
1200 if (SUCCEEDED(hr = buffer_test_offset(buffer, offset, sizeof(*data))))
1201 StorageUtl_ReadULargeInteger(buffer->data, offset, data);
1202
1203 return hr;
1204 }
1205
1206 static HRESULT buffer_read_dword(const struct read_buffer *buffer, size_t offset, DWORD *data)
1207 {
1208 HRESULT hr;
1209
1210 if (SUCCEEDED(hr = buffer_test_offset(buffer, offset, sizeof(*data))))
1211 StorageUtl_ReadDWord(buffer->data, offset, data);
1212
1213 return hr;
1214 }
1215
1216 static HRESULT buffer_read_word(const struct read_buffer *buffer, size_t offset, WORD *data)
1217 {
1218 HRESULT hr;
1219
1220 if (SUCCEEDED(hr = buffer_test_offset(buffer, offset, sizeof(*data))))
1221 StorageUtl_ReadWord(buffer->data, offset, data);
1222
1223 return hr;
1224 }
1225
1226 static HRESULT buffer_read_byte(const struct read_buffer *buffer, size_t offset, BYTE *data)
1227 {
1228 HRESULT hr;
1229
1230 if (SUCCEEDED(hr = buffer_test_offset(buffer, offset, sizeof(*data))))
1231 *data = *(buffer->data + offset);
1232
1233 return hr;
1234 }
1235
1236 static HRESULT buffer_read_len(const struct read_buffer *buffer, size_t offset, void *dest, size_t len)
1237 {
1238 HRESULT hr;
1239
1240 if (SUCCEEDED(hr = buffer_test_offset(buffer, offset, len)))
1241 memcpy(dest, buffer->data + offset, len);
1242
1243 return hr;
1244 }
1245
1246 static HRESULT propertystorage_read_scalar(PROPVARIANT *prop, const struct read_buffer *buffer, size_t offset,
1247 UINT codepage, void* (WINAPI *allocate)(void *this, ULONG size), void *allocate_data)
1248 {
1249 HRESULT hr;
1250
1251 assert(!(prop->vt & (VT_ARRAY | VT_VECTOR)));
1252
1253 switch (prop->vt)
1254 {
1255 case VT_EMPTY:
1256 case VT_NULL:
1257 hr = S_OK;
1258 break;
1259 case VT_I1:
1260 hr = buffer_read_byte(buffer, offset, (BYTE *)&prop->cVal);
1261 TRACE("Read char 0x%x ('%c')\n", prop->cVal, prop->cVal);
1262 break;
1263 case VT_UI1:
1264 hr = buffer_read_byte(buffer, offset, &prop->bVal);
1265 TRACE("Read byte 0x%x\n", prop->bVal);
1266 break;
1267 case VT_BOOL:
1268 hr = buffer_read_word(buffer, offset, (WORD *)&prop->boolVal);
1269 TRACE("Read bool %d\n", prop->boolVal);
1270 break;
1271 case VT_I2:
1272 hr = buffer_read_word(buffer, offset, (WORD *)&prop->iVal);
1273 TRACE("Read short %d\n", prop->iVal);
1274 break;
1275 case VT_UI2:
1276 hr = buffer_read_word(buffer, offset, &prop->uiVal);
1277 TRACE("Read ushort %d\n", prop->uiVal);
1278 break;
1279 case VT_INT:
1280 case VT_I4:
1281 hr = buffer_read_dword(buffer, offset, (DWORD *)&prop->lVal);
1282 TRACE("Read long %ld\n", prop->lVal);
1283 break;
1284 case VT_UINT:
1285 case VT_UI4:
1286 hr = buffer_read_dword(buffer, offset, &prop->ulVal);
1287 TRACE("Read ulong %ld\n", prop->ulVal);
1288 break;
1289 case VT_I8:
1290 hr = buffer_read_uint64(buffer, offset, (ULARGE_INTEGER *)&prop->hVal);
1291 TRACE("Read long long %s\n", wine_dbgstr_longlong(prop->hVal.QuadPart));
1292 break;
1293 case VT_UI8:
1294 hr = buffer_read_uint64(buffer, offset, &prop->uhVal);
1295 TRACE("Read ulong long %s\n", wine_dbgstr_longlong(prop->uhVal.QuadPart));
1296 break;
1297 case VT_R8:
1298 hr = buffer_read_len(buffer, offset, &prop->dblVal, sizeof(prop->dblVal));
1299 TRACE("Read double %f\n", prop->dblVal);
1300 break;
1301 case VT_LPSTR:
1302 {
1303 DWORD count;
1304
1305 if (FAILED(hr = buffer_read_dword(buffer, offset, &count)))
1306 break;
1307
1308 offset += sizeof(DWORD);
1309
1310 if (codepage == CP_UNICODE && count % sizeof(WCHAR))
1311 {
1312 WARN("Unicode string has odd number of bytes\n");
1313 hr = STG_E_INVALIDHEADER;
1314 }
1315 else
1316 {
1317 prop->pszVal = allocate(allocate_data, count);
1318 if (prop->pszVal)
1319 {
1320 if (FAILED(hr = buffer_read_len(buffer, offset, prop->pszVal, count)))
1321 break;
1322
1323 /* This is stored in the code page specified in codepage.
1324 * Don't convert it, the caller will just store it as-is.
1325 */
1326 if (codepage == CP_UNICODE)
1327 {
1328 /* Make sure it's NULL-terminated */
1329 prop->pszVal[count / sizeof(WCHAR) - 1] = '\0';
1330 TRACE("Read string value %s\n",
1331 debugstr_w(prop->pwszVal));
1332 }
1333 else
1334 {
1335 /* Make sure it's NULL-terminated */
1336 prop->pszVal[count - 1] = '\0';
1337 TRACE("Read string value %s\n", debugstr_a(prop->pszVal));
1338 }
1339 }
1340 else
1341 hr = STG_E_INSUFFICIENTMEMORY;
1342 }
1343 break;
1344 }
1345 case VT_BSTR:
1346 {
1347 DWORD count, wcount;
1348
1349 if (FAILED(hr = buffer_read_dword(buffer, offset, &count)))
1350 break;
1351
1352 offset += sizeof(DWORD);
1353
1354 if (codepage == CP_UNICODE && count % sizeof(WCHAR))
1355 {
1356 WARN("Unicode string has odd number of bytes\n");
1357 hr = STG_E_INVALIDHEADER;
1358 }
1359 else
1360 {
1361 if (codepage == CP_UNICODE)
1362 wcount = count / sizeof(WCHAR);
1363 else
1364 {
1365 if (FAILED(hr = buffer_test_offset(buffer, offset, count)))
1366 break;
1367 wcount = MultiByteToWideChar(codepage, 0, (LPCSTR)(buffer->data + offset), count, NULL, 0);
1368 }
1369
1370 prop->bstrVal = SysAllocStringLen(NULL, wcount); /* FIXME: use allocator? */
1371
1372 if (prop->bstrVal)
1373 {
1374 if (codepage == CP_UNICODE)
1375 hr = buffer_read_len(buffer, offset, prop->bstrVal, count);
1376 else
1377 MultiByteToWideChar(codepage, 0, (LPCSTR)(buffer->data + offset), count, prop->bstrVal, wcount);
1378
1379 prop->bstrVal[wcount - 1] = '\0';
1380 TRACE("Read string value %s\n", debugstr_w(prop->bstrVal));
1381 }
1382 else
1383 hr = STG_E_INSUFFICIENTMEMORY;
1384 }
1385 break;
1386 }
1387 case VT_BLOB:
1388 {
1389 DWORD count;
1390
1391 if (FAILED(hr = buffer_read_dword(buffer, offset, &count)))
1392 break;
1393
1394 offset += sizeof(DWORD);
1395
1396 prop->blob.cbSize = count;
1397 prop->blob.pBlobData = allocate(allocate_data, count);
1398 if (prop->blob.pBlobData)
1399 {
1400 hr = buffer_read_len(buffer, offset, prop->blob.pBlobData, count);
1401 TRACE("Read blob value of size %ld\n", count);
1402 }
1403 else
1404 hr = STG_E_INSUFFICIENTMEMORY;
1405 break;
1406 }
1407 case VT_LPWSTR:
1408 {
1409 DWORD count;
1410
1411 if (FAILED(hr = buffer_read_dword(buffer, offset, &count)))
1412 break;
1413
1414 offset += sizeof(DWORD);
1415
1416 prop->pwszVal = allocate(allocate_data, count * sizeof(WCHAR));
1417 if (prop->pwszVal)
1418 {
1419 if (SUCCEEDED(hr = buffer_read_len(buffer, offset, prop->pwszVal, count * sizeof(WCHAR))))
1420 {
1421 /* make sure string is NULL-terminated */
1422 prop->pwszVal[count - 1] = '\0';
1423 PropertyStorage_ByteSwapString(prop->pwszVal, count);
1424 TRACE("Read string value %s\n", debugstr_w(prop->pwszVal));
1425 }
1426 }
1427 else
1428 hr = STG_E_INSUFFICIENTMEMORY;
1429 break;
1430 }
1431 case VT_FILETIME:
1432 hr = buffer_read_uint64(buffer, offset, (ULARGE_INTEGER *)&prop->filetime);
1433 break;
1434 case VT_CF:
1435 {
1436 DWORD len = 0, tag = 0;
1437
1438 if (SUCCEEDED(hr = buffer_read_dword(buffer, offset, &len)))
1439 hr = buffer_read_dword(buffer, offset + sizeof(DWORD), &tag);
1440 if (FAILED(hr))
1441 break;
1442
1443 offset += 2 * sizeof(DWORD);
1444
1445 if (len > 8)
1446 {
1447 len -= 8;
1448 prop->pclipdata = allocate(allocate_data, sizeof (CLIPDATA));
1449 prop->pclipdata->cbSize = len;
1450 prop->pclipdata->ulClipFmt = tag;
1451 prop->pclipdata->pClipData = allocate(allocate_data, len - sizeof(prop->pclipdata->ulClipFmt));
1452 hr = buffer_read_len(buffer, offset, prop->pclipdata->pClipData, len - sizeof(prop->pclipdata->ulClipFmt));
1453 }
1454 else
1455 hr = STG_E_INVALIDPARAMETER;
1456 }
1457 break;
1458 case VT_CLSID:
1459 if (!(prop->puuid = allocate(allocate_data, sizeof (*prop->puuid))))
1460 return STG_E_INSUFFICIENTMEMORY;
1461
1462 if (SUCCEEDED(hr = buffer_test_offset(buffer, offset, sizeof(*prop->puuid))))
1463 StorageUtl_ReadGUID(buffer->data, offset, prop->puuid);
1464
1465 break;
1466 default:
1467 FIXME("unsupported type %d\n", prop->vt);
1468 hr = STG_E_INVALIDPARAMETER;
1469 }
1470
1471 return hr;
1472 }
1473
1474 static size_t propertystorage_get_elemsize(const PROPVARIANT *prop)
1475 {
1476 if (!(prop->vt & VT_VECTOR))
1477 return 0;
1478
1479 switch (prop->vt & ~VT_VECTOR)
1480 {
1481 case VT_I1: return sizeof(*prop->cac.pElems);
1482 case VT_UI1: return sizeof(*prop->caub.pElems);
1483 case VT_I2: return sizeof(*prop->cai.pElems);
1484 case VT_UI2: return sizeof(*prop->caui.pElems);
1485 case VT_BOOL: return sizeof(*prop->cabool.pElems);
1486 case VT_I4: return sizeof(*prop->cal.pElems);
1487 case VT_UI4: return sizeof(*prop->caul.pElems);
1488 case VT_R4: return sizeof(*prop->caflt.pElems);
1489 case VT_ERROR: return sizeof(*prop->cascode.pElems);
1490 case VT_I8: return sizeof(*prop->cah.pElems);
1491 case VT_UI8: return sizeof(*prop->cauh.pElems);
1492 case VT_R8: return sizeof(*prop->cadbl.pElems);
1493 case VT_CY: return sizeof(*prop->cacy.pElems);
1494 case VT_DATE: return sizeof(*prop->cadate.pElems);
1495 case VT_FILETIME: return sizeof(*prop->cafiletime.pElems);
1496 case VT_CLSID: return sizeof(*prop->cauuid.pElems);
1497 case VT_VARIANT: return sizeof(*prop->capropvar.pElems);
1498 default:
1499 FIXME("Unhandled type %#x.\n", prop->vt);
1500 return 0;
1501 }
1502 }
1503
1504 static HRESULT PropertyStorage_ReadProperty(PROPVARIANT *prop, const struct read_buffer *buffer,
1505 size_t offset, UINT codepage, void* (WINAPI *allocate)(void *this, ULONG size), void *allocate_data)
1506 {
1507 HRESULT hr;
1508 DWORD vt;
1509
1510 assert(prop);
1511 assert(buffer->data);
1512
1513 if (FAILED(hr = buffer_read_dword(buffer, offset, &vt)))
1514 return hr;
1515
1516 offset += sizeof(DWORD);
1517 prop->vt = vt;
1518
1519 if (prop->vt & VT_VECTOR)
1520 {
1521 DWORD count, i;
1522
1523 switch (prop->vt & VT_VECTOR)
1524 {
1525 case VT_BSTR:
1526 case VT_VARIANT:
1527 case VT_LPSTR:
1528 case VT_LPWSTR:
1529 case VT_CF:
1530 FIXME("Vector with variable length elements are not supported.\n");
1531 return STG_E_INVALIDPARAMETER;
1532 default:
1533 ;
1534 }
1535
1536 if (SUCCEEDED(hr = buffer_read_dword(buffer, offset, &count)))
1537 {
1538 size_t elemsize = propertystorage_get_elemsize(prop);
1539 PROPVARIANT elem;
1540
1541 offset += sizeof(DWORD);
1542
1543 if ((prop->capropvar.pElems = allocate(allocate_data, elemsize * count)))
1544 {
1545 prop->capropvar.cElems = count;
1546 elem.vt = prop->vt & ~VT_VECTOR;
1547
1548 for (i = 0; i < count; ++i)
1549 {
1550 if (SUCCEEDED(hr = propertystorage_read_scalar(&elem, buffer, offset + i * elemsize, codepage,
1551 allocate, allocate_data)))
1552 {
1553 memcpy(&prop->capropvar.pElems[i], &elem.lVal, elemsize);
1554 }
1555 }
1556 }
1557 else
1558 hr = STG_E_INSUFFICIENTMEMORY;
1559 }
1560 }
1561 else if (prop->vt & VT_ARRAY)
1562 {
1563 FIXME("VT_ARRAY properties are not supported.\n");
1564 hr = STG_E_INVALIDPARAMETER;
1565 }
1566 else
1567 hr = propertystorage_read_scalar(prop, buffer, offset, codepage, allocate, allocate_data);
1568
1569 return hr;
1570 }
1571
1572 static HRESULT PropertyStorage_ReadHeaderFromStream(IStream *stm,
1573 PROPERTYSETHEADER *hdr)
1574 {
1575 BYTE buf[sizeof(PROPERTYSETHEADER)];
1576 ULONG count = 0;
1577 HRESULT hr;
1578
1579 assert(stm);
1580 assert(hdr);
1581 hr = IStream_Read(stm, buf, sizeof(buf), &count);
1582 if (SUCCEEDED(hr))
1583 {
1584 if (count != sizeof(buf))
1585 {
1586 WARN("read only %ld\n", count);
1587 hr = STG_E_INVALIDHEADER;
1588 }
1589 else
1590 {
1591 StorageUtl_ReadWord(buf, offsetof(PROPERTYSETHEADER, wByteOrder),
1592 &hdr->wByteOrder);
1593 StorageUtl_ReadWord(buf, offsetof(PROPERTYSETHEADER, wFormat),
1594 &hdr->wFormat);
1595 StorageUtl_ReadDWord(buf, offsetof(PROPERTYSETHEADER, dwOSVer),
1596 &hdr->dwOSVer);
1597 StorageUtl_ReadGUID(buf, offsetof(PROPERTYSETHEADER, clsid),
1598 &hdr->clsid);
1599 StorageUtl_ReadDWord(buf, offsetof(PROPERTYSETHEADER, reserved),
1600 &hdr->reserved);
1601 }
1602 }
1603 TRACE("returning %#lx\n", hr);
1604 return hr;
1605 }
1606
1607 static HRESULT PropertyStorage_ReadFmtIdOffsetFromStream(IStream *stm,
1608 FORMATIDOFFSET *fmt)
1609 {
1610 BYTE buf[sizeof(FORMATIDOFFSET)];
1611 ULONG count = 0;
1612 HRESULT hr;
1613
1614 assert(stm);
1615 assert(fmt);
1616 hr = IStream_Read(stm, buf, sizeof(buf), &count);
1617 if (SUCCEEDED(hr))
1618 {
1619 if (count != sizeof(buf))
1620 {
1621 WARN("read only %ld\n", count);
1622 hr = STG_E_INVALIDHEADER;
1623 }
1624 else
1625 {
1626 StorageUtl_ReadGUID(buf, offsetof(FORMATIDOFFSET, fmtid),
1627 &fmt->fmtid);
1628 StorageUtl_ReadDWord(buf, offsetof(FORMATIDOFFSET, dwOffset),
1629 &fmt->dwOffset);
1630 }
1631 }
1632 TRACE("returning %#lx\n", hr);
1633 return hr;
1634 }
1635
1636 static HRESULT PropertyStorage_ReadSectionHeaderFromStream(IStream *stm,
1637 PROPERTYSECTIONHEADER *hdr)
1638 {
1639 BYTE buf[sizeof(PROPERTYSECTIONHEADER)];
1640 ULONG count = 0;
1641 HRESULT hr;
1642
1643 assert(stm);
1644 assert(hdr);
1645 hr = IStream_Read(stm, buf, sizeof(buf), &count);
1646 if (SUCCEEDED(hr))
1647 {
1648 if (count != sizeof(buf))
1649 {
1650 WARN("read only %ld\n", count);
1651 hr = STG_E_INVALIDHEADER;
1652 }
1653 else
1654 {
1655 StorageUtl_ReadDWord(buf, offsetof(PROPERTYSECTIONHEADER,
1656 cbSection), &hdr->cbSection);
1657 StorageUtl_ReadDWord(buf, offsetof(PROPERTYSECTIONHEADER,
1658 cProperties), &hdr->cProperties);
1659 }
1660 }
1661 TRACE("returning %#lx\n", hr);
1662 return hr;
1663 }
1664
1665 /* Reads the dictionary from the memory buffer beginning at ptr. Interprets
1666 * the entries according to the values of This->codePage and This->locale.
1667 */
1668 static HRESULT PropertyStorage_ReadDictionary(PropertyStorage_impl *This, const struct read_buffer *buffer,
1669 size_t offset)
1670 {
1671 DWORD numEntries, i;
1672 HRESULT hr;
1673
1674 assert(This->name_to_propid);
1675 assert(This->propid_to_name);
1676
1677 if (FAILED(hr = buffer_read_dword(buffer, offset, &numEntries)))
1678 return hr;
1679
1680 TRACE("Reading %ld entries:\n", numEntries);
1681
1682 offset += sizeof(DWORD);
1683
1684 for (i = 0; SUCCEEDED(hr) && i < numEntries; i++)
1685 {
1686 PROPID propid;
1687 DWORD cbEntry;
1688 WCHAR ch = 0;
1689
1690 if (SUCCEEDED(hr = buffer_read_dword(buffer, offset, &propid)))
1691 hr = buffer_read_dword(buffer, offset + sizeof(PROPID), &cbEntry);
1692 if (FAILED(hr))
1693 break;
1694
1695 offset += sizeof(PROPID) + sizeof(DWORD);
1696
1697 if (FAILED(hr = buffer_test_offset(buffer, offset, This->codePage == CP_UNICODE ?
1698 ALIGNED_LENGTH(cbEntry * sizeof(WCHAR), 3) : cbEntry)))
1699 {
1700 WARN("Broken name length for entry %ld.\n", i);
1701 return hr;
1702 }
1703
1704 /* Make sure the source string is NULL-terminated */
1705 if (This->codePage != CP_UNICODE)
1706 buffer_read_byte(buffer, offset + cbEntry - 1, (BYTE *)&ch);
1707 else
1708 buffer_read_word(buffer, offset + (cbEntry - 1) * sizeof(WCHAR), &ch);
1709
1710 if (ch)
1711 {
1712 WARN("Dictionary entry name %ld is not null-terminated.\n", i);
1713 return E_FAIL;
1714 }
1715
1716 TRACE("Reading entry with ID %#lx, %ld chars, name %s.\n", propid, cbEntry, This->codePage == CP_UNICODE ?
1717 debugstr_wn((WCHAR *)buffer->data, cbEntry) : debugstr_an((char *)buffer->data, cbEntry));
1718
1719 hr = PropertyStorage_StoreNameWithId(This, (char *)buffer->data + offset, This->codePage, propid);
1720 /* Unicode entries are padded to DWORD boundaries */
1721 if (This->codePage == CP_UNICODE)
1722 cbEntry = ALIGNED_LENGTH(cbEntry * sizeof(WCHAR), 3);
1723
1724 offset += cbEntry;
1725 }
1726
1727 return hr;
1728 }
1729
1730 static HRESULT PropertyStorage_ReadFromStream(PropertyStorage_impl *This)
1731 {
1732 struct read_buffer read_buffer;
1733 PROPERTYSETHEADER hdr;
1734 FORMATIDOFFSET fmtOffset;
1735 PROPERTYSECTIONHEADER sectionHdr;
1736 LARGE_INTEGER seek;
1737 ULONG i;
1738 STATSTG stat;
1739 HRESULT hr;
1740 BYTE *buf = NULL;
1741 ULONG count = 0;
1742 DWORD dictOffset = 0;
1743
1744 This->dirty = FALSE;
1745 This->highestProp = 0;
1746 hr = IStream_Stat(This->stm, &stat, STATFLAG_NONAME);
1747 if (FAILED(hr))
1748 goto end;
1749 if (stat.cbSize.u.HighPart)
1750 {
1751 WARN("stream too big\n");
1752 /* maximum size varies, but it can't be this big */
1753 hr = STG_E_INVALIDHEADER;
1754 goto end;
1755 }
1756 if (stat.cbSize.u.LowPart == 0)
1757 {
1758 /* empty stream is okay */
1759 hr = S_OK;
1760 goto end;
1761 }
1762 else if (stat.cbSize.u.LowPart < sizeof(PROPERTYSETHEADER) +
1763 sizeof(FORMATIDOFFSET))
1764 {
1765 WARN("stream too small\n");
1766 hr = STG_E_INVALIDHEADER;
1767 goto end;
1768 }
1769 seek.QuadPart = 0;
1770 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
1771 if (FAILED(hr))
1772 goto end;
1773 hr = PropertyStorage_ReadHeaderFromStream(This->stm, &hdr);
1774 /* I've only seen reserved == 1, but the article says I shouldn't disallow
1775 * higher values.
1776 */
1777 if (hdr.wByteOrder != PROPSETHDR_BYTEORDER_MAGIC || hdr.reserved < 1)
1778 {
1779 WARN("bad magic in prop set header\n");
1780 hr = STG_E_INVALIDHEADER;
1781 goto end;
1782 }
1783 if (hdr.wFormat != 0 && hdr.wFormat != 1)
1784 {
1785 WARN("bad format version %d\n", hdr.wFormat);
1786 hr = STG_E_INVALIDHEADER;
1787 goto end;
1788 }
1789 This->format = hdr.wFormat;
1790 This->clsid = hdr.clsid;
1791 This->originatorOS = hdr.dwOSVer;
1792 if (PROPSETHDR_OSVER_KIND(hdr.dwOSVer) == PROPSETHDR_OSVER_KIND_MAC)
1793 WARN("File comes from a Mac, strings will probably be screwed up\n");
1794 hr = PropertyStorage_ReadFmtIdOffsetFromStream(This->stm, &fmtOffset);
1795 if (FAILED(hr))
1796 goto end;
1797 if (fmtOffset.dwOffset > stat.cbSize.u.LowPart)
1798 {
1799 WARN("invalid offset %ld (stream length is %ld)\n", fmtOffset.dwOffset, stat.cbSize.u.LowPart);
1800 hr = STG_E_INVALIDHEADER;
1801 goto end;
1802 }
1803 /* wackiness alert: if the format ID is FMTID_DocSummaryInformation, there
1804 * follows not one, but two sections. The first contains the standard properties
1805 * for the document summary information, and the second consists of user-defined
1806 * properties. This is the only case in which multiple sections are
1807 * allowed.
1808 * Reading the second stream isn't implemented yet.
1809 */
1810 hr = PropertyStorage_ReadSectionHeaderFromStream(This->stm, &sectionHdr);
1811 if (FAILED(hr))
1812 goto end;
1813 /* The section size includes the section header, so check it */
1814 if (sectionHdr.cbSection < sizeof(PROPERTYSECTIONHEADER))
1815 {
1816 WARN("section header too small, got %ld\n", sectionHdr.cbSection);
1817 hr = STG_E_INVALIDHEADER;
1818 goto end;
1819 }
1820 buf = HeapAlloc(GetProcessHeap(), 0, sectionHdr.cbSection -
1821 sizeof(PROPERTYSECTIONHEADER));
1822 if (!buf)
1823 {
1824 hr = STG_E_INSUFFICIENTMEMORY;
1825 goto end;
1826 }
1827 read_buffer.data = buf;
1828 read_buffer.size = sectionHdr.cbSection - sizeof(sectionHdr);
1829
1830 hr = IStream_Read(This->stm, read_buffer.data, read_buffer.size, &count);
1831 if (FAILED(hr))
1832 goto end;
1833 TRACE("Reading %ld properties:\n", sectionHdr.cProperties);
1834 for (i = 0; SUCCEEDED(hr) && i < sectionHdr.cProperties; i++)
1835 {
1836 PROPERTYIDOFFSET *idOffset = (PROPERTYIDOFFSET *)(read_buffer.data +
1837 i * sizeof(PROPERTYIDOFFSET));
1838
1839 if (idOffset->dwOffset < sizeof(PROPERTYSECTIONHEADER) ||
1840 idOffset->dwOffset > sectionHdr.cbSection - sizeof(DWORD))
1841 hr = STG_E_INVALIDPOINTER;
1842 else
1843 {
1844 if (idOffset->propid >= PID_FIRST_USABLE &&
1845 idOffset->propid < PID_MIN_READONLY && idOffset->propid >
1846 This->highestProp)
1847 This->highestProp = idOffset->propid;
1848 if (idOffset->propid == PID_DICTIONARY)
1849 {
1850 /* Don't read the dictionary yet, its entries depend on the
1851 * code page. Just store the offset so we know to read it
1852 * later.
1853 */
1854 dictOffset = idOffset->dwOffset;
1855 TRACE("Dictionary offset is %ld\n", dictOffset);
1856 }
1857 else
1858 {
1859 PROPVARIANT prop;
1860
1861 PropVariantInit(&prop);
1862 if (SUCCEEDED(PropertyStorage_ReadProperty(&prop, &read_buffer,
1863 idOffset->dwOffset - sizeof(PROPERTYSECTIONHEADER), This->codePage,
1864 Allocate_CoTaskMemAlloc, NULL)))
1865 {
1866 TRACE("Read property with ID %#lx, type %d\n", idOffset->propid, prop.vt);
1867 switch(idOffset->propid)
1868 {
1869 case PID_CODEPAGE:
1870 if (prop.vt == VT_I2)
1871 This->codePage = (USHORT)prop.iVal;
1872 break;
1873 case PID_LOCALE:
1874 if (prop.vt == VT_I4)
1875 This->locale = (LCID)prop.lVal;
1876 break;
1877 case PID_BEHAVIOR:
1878 if (prop.vt == VT_I4 && prop.lVal)
1879 This->grfFlags |= PROPSETFLAG_CASE_SENSITIVE;
1880 /* The format should already be 1, but just in case */
1881 This->format = 1;
1882 break;
1883 default:
1884 hr = PropertyStorage_StorePropWithId(This,
1885 idOffset->propid, &prop, This->codePage);
1886 }
1887 }
1888 PropVariantClear(&prop);
1889 }
1890 }
1891 }
1892 if (!This->codePage)
1893 {
1894 /* default to Unicode unless told not to, as specified on msdn */
1895 if (This->grfFlags & PROPSETFLAG_ANSI)
1896 This->codePage = GetACP();
1897 else
1898 This->codePage = CP_UNICODE;
1899 }
1900 if (!This->locale)
1901 This->locale = LOCALE_SYSTEM_DEFAULT;
1902 TRACE("Code page is %d, locale is %ld\n", This->codePage, This->locale);
1903 if (dictOffset)
1904 hr = PropertyStorage_ReadDictionary(This, &read_buffer, dictOffset - sizeof(PROPERTYSECTIONHEADER));
1905
1906 end:
1907 HeapFree(GetProcessHeap(), 0, buf);
1908 if (FAILED(hr))
1909 {
1910 dictionary_destroy(This->name_to_propid);
1911 This->name_to_propid = NULL;
1912 dictionary_destroy(This->propid_to_name);
1913 This->propid_to_name = NULL;
1914 dictionary_destroy(This->propid_to_prop);
1915 This->propid_to_prop = NULL;
1916 }
1917 return hr;
1918 }
1919
1920 static void PropertyStorage_MakeHeader(PropertyStorage_impl *This,
1921 PROPERTYSETHEADER *hdr)
1922 {
1923 assert(hdr);
1924 StorageUtl_WriteWord(&hdr->wByteOrder, 0, PROPSETHDR_BYTEORDER_MAGIC);
1925 StorageUtl_WriteWord(&hdr->wFormat, 0, This->format);
1926 StorageUtl_WriteDWord(&hdr->dwOSVer, 0, This->originatorOS);
1927 StorageUtl_WriteGUID(&hdr->clsid, 0, &This->clsid);
1928 StorageUtl_WriteDWord(&hdr->reserved, 0, 1);
1929 }
1930
1931 static void PropertyStorage_MakeFmtIdOffset(PropertyStorage_impl *This,
1932 FORMATIDOFFSET *fmtOffset)
1933 {
1934 assert(fmtOffset);
1935 StorageUtl_WriteGUID(fmtOffset, 0, &This->fmtid);
1936 StorageUtl_WriteDWord(fmtOffset, offsetof(FORMATIDOFFSET, dwOffset),
1937 sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET));
1938 }
1939
1940 static void PropertyStorage_MakeSectionHdr(DWORD cbSection, DWORD numProps,
1941 PROPERTYSECTIONHEADER *hdr)
1942 {
1943 assert(hdr);
1944 StorageUtl_WriteDWord(hdr, 0, cbSection);
1945 StorageUtl_WriteDWord(hdr, offsetof(PROPERTYSECTIONHEADER, cProperties), numProps);
1946 }
1947
1948 static void PropertyStorage_MakePropertyIdOffset(DWORD propid, DWORD dwOffset,
1949 PROPERTYIDOFFSET *propIdOffset)
1950 {
1951 assert(propIdOffset);
1952 StorageUtl_WriteDWord(propIdOffset, 0, propid);
1953 StorageUtl_WriteDWord(propIdOffset, offsetof(PROPERTYIDOFFSET, dwOffset), dwOffset);
1954 }
1955
1956 static inline HRESULT PropertyStorage_WriteWStringToStream(IStream *stm,
1957 LPCWSTR str, DWORD len, DWORD *written)
1958 {
1959 #ifdef WORDS_BIGENDIAN
1960 WCHAR *leStr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1961 HRESULT hr;
1962
1963 if (!leStr)
1964 return E_OUTOFMEMORY;
1965 memcpy(leStr, str, len * sizeof(WCHAR));
1966 PropertyStorage_ByteSwapString(leStr, len);
1967 hr = IStream_Write(stm, leStr, len, written);
1968 HeapFree(GetProcessHeap(), 0, leStr);
1969 return hr;
1970 #else
1971 return IStream_Write(stm, str, len * sizeof(WCHAR), written);
1972 #endif
1973 }
1974
1975 struct DictionaryClosure
1976 {
1977 HRESULT hr;
1978 DWORD bytesWritten;
1979 };
1980
1981 static BOOL PropertyStorage_DictionaryWriter(const void *key,
1982 const void *value, void *extra, void *closure)
1983 {
1984 PropertyStorage_impl *This = extra;
1985 struct DictionaryClosure *c = closure;
1986 DWORD propid, keyLen;
1987 ULONG count;
1988
1989 assert(key);
1990 assert(closure);
1991 StorageUtl_WriteDWord(&propid, 0, PtrToUlong(value));
1992 c->hr = IStream_Write(This->stm, &propid, sizeof(propid), &count);
1993 if (FAILED(c->hr))
1994 goto end;
1995 c->bytesWritten += sizeof(DWORD);
1996 if (This->codePage == CP_UNICODE)
1997 {
1998 DWORD pad = 0, pad_len;
1999
2000 StorageUtl_WriteDWord(&keyLen, 0, lstrlenW((LPCWSTR)key) + 1);
2001 c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
2002 if (FAILED(c->hr))
2003 goto end;
2004 c->bytesWritten += sizeof(DWORD);
2005 c->hr = PropertyStorage_WriteWStringToStream(This->stm, key, keyLen,
2006 &count);
2007 if (FAILED(c->hr))
2008 goto end;
2009 keyLen *= sizeof(WCHAR);
2010 c->bytesWritten += keyLen;
2011
2012 /* Align to 4 bytes. */
2013 pad_len = sizeof(DWORD) - keyLen % sizeof(DWORD);
2014 if (pad_len)
2015 {
2016 c->hr = IStream_Write(This->stm, &pad, pad_len, &count);
2017 if (FAILED(c->hr))
2018 goto end;
2019 c->bytesWritten += pad_len;
2020 }
2021 }
2022 else
2023 {
2024 StorageUtl_WriteDWord(&keyLen, 0, strlen((LPCSTR)key) + 1);
2025 c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
2026 if (FAILED(c->hr))
2027 goto end;
2028 c->bytesWritten += sizeof(DWORD);
2029 c->hr = IStream_Write(This->stm, key, keyLen, &count);
2030 if (FAILED(c->hr))
2031 goto end;
2032 c->bytesWritten += keyLen;
2033 }
2034 end:
2035 return SUCCEEDED(c->hr);
2036 }
2037
2038 #define SECTIONHEADER_OFFSET sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET)
2039
2040 /* Writes the dictionary to the stream. Assumes without checking that the
2041 * dictionary isn't empty.
2042 */
2043 static HRESULT PropertyStorage_WriteDictionaryToStream(
2044 PropertyStorage_impl *This, DWORD *sectionOffset)
2045 {
2046 HRESULT hr;
2047 LARGE_INTEGER seek;
2048 PROPERTYIDOFFSET propIdOffset;
2049 ULONG count;
2050 DWORD dwTemp;
2051 struct DictionaryClosure closure;
2052
2053 assert(sectionOffset);
2054
2055 /* The dictionary's always the first property written, so seek to its
2056 * spot.
2057 */
2058 seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER);
2059 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2060 if (FAILED(hr))
2061 goto end;
2062 PropertyStorage_MakePropertyIdOffset(PID_DICTIONARY, *sectionOffset,
2063 &propIdOffset);
2064 hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
2065 if (FAILED(hr))
2066 goto end;
2067
2068 seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
2069 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2070 if (FAILED(hr))
2071 goto end;
2072 StorageUtl_WriteDWord(&dwTemp, 0, dictionary_num_entries(This->name_to_propid));
2073 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2074 if (FAILED(hr))
2075 goto end;
2076 *sectionOffset += sizeof(dwTemp);
2077
2078 closure.hr = S_OK;
2079 closure.bytesWritten = 0;
2080 dictionary_enumerate(This->name_to_propid, PropertyStorage_DictionaryWriter,
2081 &closure);
2082 hr = closure.hr;
2083 if (FAILED(hr))
2084 goto end;
2085 *sectionOffset += closure.bytesWritten;
2086 if (closure.bytesWritten % sizeof(DWORD))
2087 {
2088 DWORD padding = sizeof(DWORD) - closure.bytesWritten % sizeof(DWORD);
2089 TRACE("adding %ld bytes of padding\n", padding);
2090 *sectionOffset += padding;
2091 }
2092
2093 end:
2094 return hr;
2095 }
2096
2097 static HRESULT PropertyStorage_WritePropertyToStream(PropertyStorage_impl *This,
2098 DWORD propNum, DWORD propid, const PROPVARIANT *var, DWORD *sectionOffset)
2099 {
2100 DWORD len, dwType, dwTemp, bytesWritten;
2101 HRESULT hr;
2102 LARGE_INTEGER seek;
2103 PROPERTYIDOFFSET propIdOffset;
2104 ULARGE_INTEGER ularge;
2105 ULONG count;
2106
2107 assert(var);
2108 assert(sectionOffset);
2109
2110 TRACE("%p, %ld, %#lx, %d, %ld.\n", This, propNum, propid, var->vt,
2111 *sectionOffset);
2112
2113 seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER) +
2114 propNum * sizeof(PROPERTYIDOFFSET);
2115 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2116 if (FAILED(hr))
2117 goto end;
2118 PropertyStorage_MakePropertyIdOffset(propid, *sectionOffset, &propIdOffset);
2119 hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
2120 if (FAILED(hr))
2121 goto end;
2122
2123 seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
2124 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2125 if (FAILED(hr))
2126 goto end;
2127 StorageUtl_WriteDWord(&dwType, 0, var->vt);
2128 hr = IStream_Write(This->stm, &dwType, sizeof(dwType), &count);
2129 if (FAILED(hr))
2130 goto end;
2131 *sectionOffset += sizeof(dwType);
2132
2133 switch (var->vt)
2134 {
2135 case VT_EMPTY:
2136 case VT_NULL:
2137 bytesWritten = 0;
2138 break;
2139 case VT_I1:
2140 case VT_UI1:
2141 hr = IStream_Write(This->stm, &var->cVal, sizeof(var->cVal),
2142 &count);
2143 bytesWritten = count;
2144 break;
2145 case VT_I2:
2146 case VT_UI2:
2147 {
2148 WORD wTemp;
2149
2150 StorageUtl_WriteWord(&wTemp, 0, var->iVal);
2151 hr = IStream_Write(This->stm, &wTemp, sizeof(wTemp), &count);
2152 bytesWritten = count;
2153 break;
2154 }
2155 case VT_I4:
2156 case VT_UI4:
2157 {
2158 StorageUtl_WriteDWord(&dwTemp, 0, var->lVal);
2159 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2160 bytesWritten = count;
2161 break;
2162 }
2163 case VT_I8:
2164 case VT_UI8:
2165 {
2166 StorageUtl_WriteULargeInteger(&ularge, 0, &var->uhVal);
2167 hr = IStream_Write(This->stm, &ularge, sizeof(ularge), &bytesWritten);
2168 break;
2169 }
2170 case VT_LPSTR:
2171 {
2172 if (This->codePage == CP_UNICODE)
2173 len = (lstrlenW(var->pwszVal) + 1) * sizeof(WCHAR);
2174 else
2175 len = lstrlenA(var->pszVal) + 1;
2176 StorageUtl_WriteDWord(&dwTemp, 0, len);
2177 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2178 if (FAILED(hr))
2179 goto end;
2180 hr = IStream_Write(This->stm, var->pszVal, len, &count);
2181 bytesWritten = count + sizeof(DWORD);
2182 break;
2183 }
2184 case VT_BSTR:
2185 {
2186 if (This->codePage == CP_UNICODE)
2187 {
2188 len = SysStringByteLen(var->bstrVal) + sizeof(WCHAR);
2189 StorageUtl_WriteDWord(&dwTemp, 0, len);
2190 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2191 if (SUCCEEDED(hr))
2192 hr = IStream_Write(This->stm, var->bstrVal, len, &count);
2193 }
2194 else
2195 {
2196 char *str;
2197
2198 len = WideCharToMultiByte(This->codePage, 0, var->bstrVal, SysStringLen(var->bstrVal) + 1,
2199 NULL, 0, NULL, NULL);
2200
2201 str = heap_alloc(len);
2202 if (!str)
2203 {
2204 hr = E_OUTOFMEMORY;
2205 goto end;
2206 }
2207
2208 WideCharToMultiByte(This->codePage, 0, var->bstrVal, SysStringLen(var->bstrVal),
2209 str, len, NULL, NULL);
2210 StorageUtl_WriteDWord(&dwTemp, 0, len);
2211 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2212 if (SUCCEEDED(hr))
2213 hr = IStream_Write(This->stm, str, len, &count);
2214 heap_free(str);
2215 }
2216
2217 bytesWritten = count + sizeof(DWORD);
2218 break;
2219 }
2220 case VT_LPWSTR:
2221 {
2222 len = lstrlenW(var->pwszVal) + 1;
2223
2224 StorageUtl_WriteDWord(&dwTemp, 0, len);
2225 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2226 if (FAILED(hr))
2227 goto end;
2228 hr = IStream_Write(This->stm, var->pwszVal, len * sizeof(WCHAR),
2229 &count);
2230 bytesWritten = count + sizeof(DWORD);
2231 break;
2232 }
2233 case VT_FILETIME:
2234 {
2235 FILETIME temp;
2236
2237 StorageUtl_WriteULargeInteger(&temp, 0, (const ULARGE_INTEGER *)&var->filetime);
2238 hr = IStream_Write(This->stm, &temp, sizeof(temp), &count);
2239 bytesWritten = count;
2240 break;
2241 }
2242 case VT_CF:
2243 {
2244 DWORD cf_hdr[2];
2245
2246 len = var->pclipdata->cbSize;
2247 StorageUtl_WriteDWord(&cf_hdr[0], 0, len + 8);
2248 StorageUtl_WriteDWord(&cf_hdr[1], 0, var->pclipdata->ulClipFmt);
2249 hr = IStream_Write(This->stm, cf_hdr, sizeof(cf_hdr), &count);
2250 if (FAILED(hr))
2251 goto end;
2252 hr = IStream_Write(This->stm, var->pclipdata->pClipData,
2253 len - sizeof(var->pclipdata->ulClipFmt), &count);
2254 if (FAILED(hr))
2255 goto end;
2256 bytesWritten = count + sizeof cf_hdr;
2257 break;
2258 }
2259 case VT_CLSID:
2260 {
2261 CLSID temp;
2262
2263 StorageUtl_WriteGUID(&temp, 0, var->puuid);
2264 hr = IStream_Write(This->stm, &temp, sizeof(temp), &count);
2265 bytesWritten = count;
2266 break;
2267 }
2268 case VT_BLOB:
2269 {
2270 StorageUtl_WriteDWord(&dwTemp, 0, var->blob.cbSize);
2271 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2272 if (FAILED(hr))
2273 goto end;
2274 hr = IStream_Write(This->stm, var->blob.pBlobData, var->blob.cbSize, &count);
2275 bytesWritten = count + sizeof(DWORD);
2276 break;
2277 }
2278 default:
2279 FIXME("unsupported type: %d\n", var->vt);
2280 return STG_E_INVALIDPARAMETER;
2281 }
2282
2283 if (SUCCEEDED(hr))
2284 {
2285 *sectionOffset += bytesWritten;
2286 if (bytesWritten % sizeof(DWORD))
2287 {
2288 DWORD padding = sizeof(DWORD) - bytesWritten % sizeof(DWORD);
2289 TRACE("adding %ld bytes of padding\n", padding);
2290 *sectionOffset += padding;
2291 }
2292 }
2293
2294 end:
2295 return hr;
2296 }
2297
2298 struct PropertyClosure
2299 {
2300 HRESULT hr;
2301 DWORD propNum;
2302 DWORD *sectionOffset;
2303 };
2304
2305 static BOOL PropertyStorage_PropertiesWriter(const void *key, const void *value,
2306 void *extra, void *closure)
2307 {
2308 PropertyStorage_impl *This = extra;
2309 struct PropertyClosure *c = closure;
2310
2311 assert(key);
2312 assert(value);
2313 assert(extra);
2314 assert(closure);
2315 c->hr = PropertyStorage_WritePropertyToStream(This, c->propNum++,
2316 PtrToUlong(key), value, c->sectionOffset);
2317 return SUCCEEDED(c->hr);
2318 }
2319
2320 static HRESULT PropertyStorage_WritePropertiesToStream(
2321 PropertyStorage_impl *This, DWORD startingPropNum, DWORD *sectionOffset)
2322 {
2323 struct PropertyClosure closure;
2324
2325 assert(sectionOffset);
2326 closure.hr = S_OK;
2327 closure.propNum = startingPropNum;
2328 closure.sectionOffset = sectionOffset;
2329 dictionary_enumerate(This->propid_to_prop, PropertyStorage_PropertiesWriter,
2330 &closure);
2331 return closure.hr;
2332 }
2333
2334 static HRESULT PropertyStorage_WriteHeadersToStream(PropertyStorage_impl *This)
2335 {
2336 HRESULT hr;
2337 ULONG count = 0;
2338 LARGE_INTEGER seek = { {0} };
2339 PROPERTYSETHEADER hdr;
2340 FORMATIDOFFSET fmtOffset;
2341
2342 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2343 if (FAILED(hr))
2344 goto end;
2345 PropertyStorage_MakeHeader(This, &hdr);
2346 hr = IStream_Write(This->stm, &hdr, sizeof(hdr), &count);
2347 if (FAILED(hr))
2348 goto end;
2349 if (count != sizeof(hdr))
2350 {
2351 hr = STG_E_WRITEFAULT;
2352 goto end;
2353 }
2354
2355 PropertyStorage_MakeFmtIdOffset(This, &fmtOffset);
2356 hr = IStream_Write(This->stm, &fmtOffset, sizeof(fmtOffset), &count);
2357 if (FAILED(hr))
2358 goto end;
2359 if (count != sizeof(fmtOffset))
2360 {
2361 hr = STG_E_WRITEFAULT;
2362 goto end;
2363 }
2364 hr = S_OK;
2365
2366 end:
2367 return hr;
2368 }
2369
2370 static HRESULT PropertyStorage_WriteToStream(PropertyStorage_impl *This)
2371 {
2372 PROPERTYSECTIONHEADER sectionHdr;
2373 HRESULT hr;
2374 ULONG count;
2375 LARGE_INTEGER seek;
2376 DWORD numProps, prop, sectionOffset, dwTemp;
2377 PROPVARIANT var;
2378
2379 PropertyStorage_WriteHeadersToStream(This);
2380
2381 /* Count properties. Always at least one property, the code page */
2382 numProps = 1;
2383 if (dictionary_num_entries(This->name_to_propid))
2384 numProps++;
2385 if (This->locale != LOCALE_SYSTEM_DEFAULT)
2386 numProps++;
2387 if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
2388 numProps++;
2389 numProps += dictionary_num_entries(This->propid_to_prop);
2390
2391 /* Write section header with 0 bytes right now, I'll adjust it after
2392 * writing properties.
2393 */
2394 PropertyStorage_MakeSectionHdr(0, numProps, &sectionHdr);
2395 seek.QuadPart = SECTIONHEADER_OFFSET;
2396 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2397 if (FAILED(hr))
2398 goto end;
2399 hr = IStream_Write(This->stm, &sectionHdr, sizeof(sectionHdr), &count);
2400 if (FAILED(hr))
2401 goto end;
2402
2403 prop = 0;
2404 sectionOffset = sizeof(PROPERTYSECTIONHEADER) +
2405 numProps * sizeof(PROPERTYIDOFFSET);
2406
2407 if (dictionary_num_entries(This->name_to_propid))
2408 {
2409 prop++;
2410 hr = PropertyStorage_WriteDictionaryToStream(This, &sectionOffset);
2411 if (FAILED(hr))
2412 goto end;
2413 }
2414
2415 PropVariantInit(&var);
2416
2417 var.vt = VT_I2;
2418 var.iVal = This->codePage;
2419 hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_CODEPAGE,
2420 &var, &sectionOffset);
2421 if (FAILED(hr))
2422 goto end;
2423
2424 if (This->locale != LOCALE_SYSTEM_DEFAULT)
2425 {
2426 var.vt = VT_I4;
2427 var.lVal = This->locale;
2428 hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_LOCALE,
2429 &var, &sectionOffset);
2430 if (FAILED(hr))
2431 goto end;
2432 }
2433
2434 if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
2435 {
2436 var.vt = VT_I4;
2437 var.lVal = 1;
2438 hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_BEHAVIOR,
2439 &var, &sectionOffset);
2440 if (FAILED(hr))
2441 goto end;
2442 }
2443
2444 hr = PropertyStorage_WritePropertiesToStream(This, prop, &sectionOffset);
2445 if (FAILED(hr))
2446 goto end;
2447
2448 /* Now write the byte count of the section */
2449 seek.QuadPart = SECTIONHEADER_OFFSET;
2450 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2451 if (FAILED(hr))
2452 goto end;
2453 StorageUtl_WriteDWord(&dwTemp, 0, sectionOffset);
2454 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2455
2456 end:
2457 return hr;
2458 }
2459
2460 /***********************************************************************
2461 * PropertyStorage_Construct
2462 */
2463 static void PropertyStorage_DestroyDictionaries(PropertyStorage_impl *This)
2464 {
2465 dictionary_destroy(This->name_to_propid);
2466 This->name_to_propid = NULL;
2467 dictionary_destroy(This->propid_to_name);
2468 This->propid_to_name = NULL;
2469 dictionary_destroy(This->propid_to_prop);
2470 This->propid_to_prop = NULL;
2471 }
2472
2473 static HRESULT PropertyStorage_CreateDictionaries(PropertyStorage_impl *This)
2474 {
2475 HRESULT hr = S_OK;
2476
2477 This->name_to_propid = dictionary_create(
2478 PropertyStorage_PropNameCompare, PropertyStorage_PropNameDestroy,
2479 This);
2480 if (!This->name_to_propid)
2481 {
2482 hr = STG_E_INSUFFICIENTMEMORY;
2483 goto end;
2484 }
2485 This->propid_to_name = dictionary_create(PropertyStorage_PropCompare,
2486 NULL, This);
2487 if (!This->propid_to_name)
2488 {
2489 hr = STG_E_INSUFFICIENTMEMORY;
2490 goto end;
2491 }
2492 This->propid_to_prop = dictionary_create(PropertyStorage_PropCompare,
2493 PropertyStorage_PropertyDestroy, This);
2494 if (!This->propid_to_prop)
2495 {
2496 hr = STG_E_INSUFFICIENTMEMORY;
2497 goto end;
2498 }
2499 end:
2500 if (FAILED(hr))
2501 PropertyStorage_DestroyDictionaries(This);
2502 return hr;
2503 }
2504
2505 static HRESULT PropertyStorage_BaseConstruct(IStream *stm,
2506 REFFMTID rfmtid, DWORD grfMode, PropertyStorage_impl **pps)
2507 {
2508 HRESULT hr = S_OK;
2509
2510 assert(pps);
2511 assert(rfmtid);
2512 *pps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof **pps);
2513 if (!*pps)
2514 return E_OUTOFMEMORY;
2515
2516 (*pps)->IPropertyStorage_iface.lpVtbl = &IPropertyStorage_Vtbl;
2517 (*pps)->ref = 1;
2518 InitializeCriticalSection(&(*pps)->cs);
2519 (*pps)->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PropertyStorage_impl.cs");
2520 (*pps)->stm = stm;
2521 (*pps)->fmtid = *rfmtid;
2522 (*pps)->grfMode = grfMode;
2523
2524 hr = PropertyStorage_CreateDictionaries(*pps);
2525 if (FAILED(hr))
2526 {
2527 (*pps)->cs.DebugInfo->Spare[0] = 0;
2528 DeleteCriticalSection(&(*pps)->cs);
2529 HeapFree(GetProcessHeap(), 0, *pps);
2530 *pps = NULL;
2531 }
2532 else IStream_AddRef( stm );
2533
2534 return hr;
2535 }
2536
2537 static HRESULT PropertyStorage_ConstructFromStream(IStream *stm,
2538 REFFMTID rfmtid, DWORD grfMode, IPropertyStorage** pps)
2539 {
2540 PropertyStorage_impl *ps;
2541 HRESULT hr;
2542
2543 assert(pps);
2544 hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
2545 if (SUCCEEDED(hr))
2546 {
2547 hr = PropertyStorage_ReadFromStream(ps);
2548 if (SUCCEEDED(hr))
2549 {
2550 *pps = &ps->IPropertyStorage_iface;
2551 TRACE("PropertyStorage %p constructed\n", ps);
2552 hr = S_OK;
2553 }
2554 else IPropertyStorage_Release( &ps->IPropertyStorage_iface );
2555 }
2556 return hr;
2557 }
2558
2559 static HRESULT PropertyStorage_ConstructEmpty(IStream *stm,
2560 REFFMTID rfmtid, DWORD grfFlags, DWORD grfMode, IPropertyStorage** pps)
2561 {
2562 PropertyStorage_impl *ps;
2563 HRESULT hr;
2564
2565 assert(pps);
2566 hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
2567 if (SUCCEEDED(hr))
2568 {
2569 ps->format = 0;
2570 ps->grfFlags = grfFlags;
2571 if (ps->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
2572 ps->format = 1;
2573 /* default to Unicode unless told not to, as specified on msdn */
2574 if (ps->grfFlags & PROPSETFLAG_ANSI)
2575 ps->codePage = GetACP();
2576 else
2577 ps->codePage = CP_UNICODE;
2578 ps->locale = LOCALE_SYSTEM_DEFAULT;
2579 TRACE("Code page is %d, locale is %ld\n", ps->codePage, ps->locale);
2580 *pps = &ps->IPropertyStorage_iface;
2581 TRACE("PropertyStorage %p constructed\n", ps);
2582 hr = S_OK;
2583 }
2584 return hr;
2585 }
2586
2587
2588 /***********************************************************************
2589 * Implementation of IPropertySetStorage
2590 */
2591
2592 struct enum_stat_propset_stg
2593 {
2594 IEnumSTATPROPSETSTG IEnumSTATPROPSETSTG_iface;
2595 LONG refcount;
2596 STATPROPSETSTG *stats;
2597 size_t current;
2598 size_t count;
2599 };
2600
2601 static struct enum_stat_propset_stg *impl_from_IEnumSTATPROPSETSTG(IEnumSTATPROPSETSTG *iface)
2602 {
2603 return CONTAINING_RECORD(iface, struct enum_stat_propset_stg, IEnumSTATPROPSETSTG_iface);
2604 }
2605
2606 static HRESULT WINAPI enum_stat_propset_stg_QueryInterface(IEnumSTATPROPSETSTG *iface, REFIID riid, void **obj)
2607 {
2608 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2609
2610 if (IsEqualIID(riid, &IID_IEnumSTATPROPSETSTG) ||
2611 IsEqualIID(riid, &IID_IUnknown))
2612 {
2613 *obj = iface;
2614 IEnumSTATPROPSETSTG_AddRef(iface);
2615 return S_OK;
2616 }
2617
2618 WARN("Unsupported interface %s.\n", debugstr_guid(riid));
2619 return E_NOINTERFACE;
2620 }
2621
2622 static ULONG WINAPI enum_stat_propset_stg_AddRef(IEnumSTATPROPSETSTG *iface)
2623 {
2624 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2625 LONG refcount = InterlockedIncrement(&psenum->refcount);
2626
2627 TRACE("%p, refcount %lu.\n", iface, refcount);
2628
2629 return refcount;
2630 }
2631
2632 static ULONG WINAPI enum_stat_propset_stg_Release(IEnumSTATPROPSETSTG *iface)
2633 {
2634 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2635 LONG refcount = InterlockedDecrement(&psenum->refcount);
2636
2637 TRACE("%p, refcount %lu.\n", iface, refcount);
2638
2639 if (!refcount)
2640 {
2641 heap_free(psenum->stats);
2642 heap_free(psenum);
2643 }
2644
2645 return refcount;
2646 }
2647
2648 static HRESULT WINAPI enum_stat_propset_stg_Next(IEnumSTATPROPSETSTG *iface, ULONG celt,
2649 STATPROPSETSTG *ret, ULONG *fetched)
2650 {
2651 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2652 ULONG count = 0;
2653
2654 TRACE("%p, %lu, %p, %p.\n", iface, celt, ret, fetched);
2655
2656 if (psenum->current == ~0u)
2657 psenum->current = 0;
2658
2659 while (count < celt && psenum->current < psenum->count)
2660 ret[count++] = psenum->stats[psenum->current++];
2661
2662 if (fetched)
2663 *fetched = count;
2664
2665 return count < celt ? S_FALSE : S_OK;
2666 }
2667
2668 static HRESULT WINAPI enum_stat_propset_stg_Skip(IEnumSTATPROPSETSTG *iface, ULONG celt)
2669 {
2670 FIXME("%p, %lu.\n", iface, celt);
2671
2672 return S_OK;
2673 }
2674
2675 static HRESULT WINAPI enum_stat_propset_stg_Reset(IEnumSTATPROPSETSTG *iface)
2676 {
2677 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2678
2679 TRACE("%p.\n", iface);
2680
2681 psenum->current = ~0u;
2682
2683 return S_OK;
2684 }
2685
2686 static HRESULT WINAPI enum_stat_propset_stg_Clone(IEnumSTATPROPSETSTG *iface, IEnumSTATPROPSETSTG **ppenum)
2687 {
2688 FIXME("%p, %p.\n", iface, ppenum);
2689
2690 return E_NOTIMPL;
2691 }
2692
2693 static const IEnumSTATPROPSETSTGVtbl enum_stat_propset_stg_vtbl =
2694 {
2695 enum_stat_propset_stg_QueryInterface,
2696 enum_stat_propset_stg_AddRef,
2697 enum_stat_propset_stg_Release,
2698 enum_stat_propset_stg_Next,
2699 enum_stat_propset_stg_Skip,
2700 enum_stat_propset_stg_Reset,
2701 enum_stat_propset_stg_Clone,
2702 };
2703
2704 static HRESULT create_enum_stat_propset_stg(StorageImpl *storage, IEnumSTATPROPSETSTG **ret)
2705 {
2706 IStorage *stg = &storage->base.IStorage_iface;
2707 IEnumSTATSTG *penum = NULL;
2708 STATSTG stat;
2709 ULONG count;
2710 HRESULT hr;
2711
2712 struct enum_stat_propset_stg *enum_obj;
2713
2714 enum_obj = heap_alloc_zero(sizeof(*enum_obj));
2715 if (!enum_obj)
2716 return E_OUTOFMEMORY;
2717
2718 enum_obj->IEnumSTATPROPSETSTG_iface.lpVtbl = &enum_stat_propset_stg_vtbl;
2719 enum_obj->refcount = 1;
2720
2721 /* add all the property set elements into a list */
2722 hr = IStorage_EnumElements(stg, 0, NULL, 0, &penum);
2723 if (FAILED(hr))
2724 goto done;
2725
2726 /* Allocate stats array and fill it. */
2727 while ((hr = IEnumSTATSTG_Next(penum, 1, &stat, &count)) == S_OK)
2728 {
2729 enum_obj->count++;
2730 CoTaskMemFree(stat.pwcsName);
2731 }
2732
2733 if (FAILED(hr))
2734 goto done;
2735
2736 enum_obj->stats = heap_alloc(enum_obj->count * sizeof(*enum_obj->stats));
2737 if (!enum_obj->stats)
2738 {
2739 hr = E_OUTOFMEMORY;
2740 goto done;
2741 }
2742 enum_obj->count = 0;
2743
2744 if (FAILED(hr = IEnumSTATSTG_Reset(penum)))
2745 goto done;
2746
2747 while (IEnumSTATSTG_Next(penum, 1, &stat, &count) == S_OK)
2748 {
2749 if (!stat.pwcsName)
2750 continue;
2751
2752 if (stat.pwcsName[0] == 5 && stat.type == STGTY_STREAM)
2753 {
2754 STATPROPSETSTG *ptr = &enum_obj->stats[enum_obj->count++];
2755
2756 PropStgNameToFmtId(stat.pwcsName, &ptr->fmtid);
2757
2758 TRACE("adding %s - %s.\n", debugstr_w(stat.pwcsName), debugstr_guid(&ptr->fmtid));
2759
2760 ptr->mtime = stat.mtime;
2761 ptr->atime = stat.atime;
2762 ptr->ctime = stat.ctime;
2763 ptr->grfFlags = stat.grfMode;
2764 ptr->clsid = stat.clsid;
2765 }
2766 CoTaskMemFree(stat.pwcsName);
2767 }
2768
2769 done:
2770
2771 if (penum)
2772 IEnumSTATSTG_Release(penum);
2773
2774 if (SUCCEEDED(hr))
2775 {
2776 *ret = &enum_obj->IEnumSTATPROPSETSTG_iface;
2777 }
2778 else
2779 {
2780 *ret = NULL;
2781 IEnumSTATPROPSETSTG_Release(&enum_obj->IEnumSTATPROPSETSTG_iface);
2782 }
2783
2784 return hr;
2785 }
2786
2787 /************************************************************************
2788 * IPropertySetStorage_fnQueryInterface (IUnknown)
2789 *
2790 * This method forwards to the common QueryInterface implementation
2791 */
2792 static HRESULT WINAPI IPropertySetStorage_fnQueryInterface(
2793 IPropertySetStorage *ppstg,
2794 REFIID riid,
2795 void** ppvObject)
2796 {
2797 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2798 return IStorage_QueryInterface( &This->base.IStorage_iface, riid, ppvObject );
2799 }
2800
2801 /************************************************************************
2802 * IPropertySetStorage_fnAddRef (IUnknown)
2803 *
2804 * This method forwards to the common AddRef implementation
2805 */
2806 static ULONG WINAPI IPropertySetStorage_fnAddRef(
2807 IPropertySetStorage *ppstg)
2808 {
2809 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2810 return IStorage_AddRef( &This->base.IStorage_iface );
2811 }
2812
2813 /************************************************************************
2814 * IPropertySetStorage_fnRelease (IUnknown)
2815 *
2816 * This method forwards to the common Release implementation
2817 */
2818 static ULONG WINAPI IPropertySetStorage_fnRelease(
2819 IPropertySetStorage *ppstg)
2820 {
2821 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2822 return IStorage_Release( &This->base.IStorage_iface );
2823 }
2824
2825 /************************************************************************
2826 * IPropertySetStorage_fnCreate (IPropertySetStorage)
2827 */
2828 static HRESULT WINAPI IPropertySetStorage_fnCreate(
2829 IPropertySetStorage *ppstg,
2830 REFFMTID rfmtid,
2831 const CLSID* pclsid,
2832 DWORD grfFlags,
2833 DWORD grfMode,
2834 IPropertyStorage** ppprstg)
2835 {
2836 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2837 WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
2838 IStream *stm = NULL;
2839 HRESULT r;
2840
2841 TRACE("%p, %s %#lx, %#lx, %p.\n", This, debugstr_guid(rfmtid), grfFlags,
2842 grfMode, ppprstg);
2843
2844 /* be picky */
2845 if (grfMode != (STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE))
2846 {
2847 r = STG_E_INVALIDFLAG;
2848 goto end;
2849 }
2850
2851 if (!rfmtid)
2852 {
2853 r = E_INVALIDARG;
2854 goto end;
2855 }
2856
2857 /* FIXME: if (grfFlags & PROPSETFLAG_NONSIMPLE), we need to create a
2858 * storage, not a stream. For now, disallow it.
2859 */
2860 if (grfFlags & PROPSETFLAG_NONSIMPLE)
2861 {
2862 FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
2863 r = STG_E_INVALIDFLAG;
2864 goto end;
2865 }
2866
2867 r = FmtIdToPropStgName(rfmtid, name);
2868 if (FAILED(r))
2869 goto end;
2870
2871 r = IStorage_CreateStream( &This->base.IStorage_iface, name, grfMode, 0, 0, &stm );
2872 if (FAILED(r))
2873 goto end;
2874
2875 r = PropertyStorage_ConstructEmpty(stm, rfmtid, grfFlags, grfMode, ppprstg);
2876
2877 IStream_Release( stm );
2878
2879 end:
2880 TRACE("returning %#lx\n", r);
2881 return r;
2882 }
2883
2884 /************************************************************************
2885 * IPropertySetStorage_fnOpen (IPropertySetStorage)
2886 */
2887 static HRESULT WINAPI IPropertySetStorage_fnOpen(
2888 IPropertySetStorage *ppstg,
2889 REFFMTID rfmtid,
2890 DWORD grfMode,
2891 IPropertyStorage** ppprstg)
2892 {
2893 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2894 IStream *stm = NULL;
2895 WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
2896 HRESULT r;
2897
2898 TRACE("%p, %s, %#lx, %p.\n", This, debugstr_guid(rfmtid), grfMode, ppprstg);
2899
2900 /* be picky */
2901 if (grfMode != (STGM_READWRITE|STGM_SHARE_EXCLUSIVE) &&
2902 grfMode != (STGM_READ|STGM_SHARE_EXCLUSIVE))
2903 {
2904 r = STG_E_INVALIDFLAG;
2905 goto end;
2906 }
2907
2908 if (!rfmtid)
2909 {
2910 r = E_INVALIDARG;
2911 goto end;
2912 }
2913
2914 r = FmtIdToPropStgName(rfmtid, name);
2915 if (FAILED(r))
2916 goto end;
2917
2918 r = IStorage_OpenStream( &This->base.IStorage_iface, name, 0, grfMode, 0, &stm );
2919 if (FAILED(r))
2920 goto end;
2921
2922 r = PropertyStorage_ConstructFromStream(stm, rfmtid, grfMode, ppprstg);
2923
2924 IStream_Release( stm );
2925
2926 end:
2927 TRACE("returning %#lx\n", r);
2928 return r;
2929 }
2930
2931 /************************************************************************
2932 * IPropertySetStorage_fnDelete (IPropertySetStorage)
2933 */
2934 static HRESULT WINAPI IPropertySetStorage_fnDelete(
2935 IPropertySetStorage *ppstg,
2936 REFFMTID rfmtid)
2937 {
2938 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2939 WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
2940 HRESULT r;
2941
2942 TRACE("%p %s\n", This, debugstr_guid(rfmtid));
2943
2944 if (!rfmtid)
2945 return E_INVALIDARG;
2946
2947 r = FmtIdToPropStgName(rfmtid, name);
2948 if (FAILED(r))
2949 return r;
2950
2951 return IStorage_DestroyElement(&This->base.IStorage_iface, name);
2952 }
2953
2954 static HRESULT WINAPI IPropertySetStorage_fnEnum(IPropertySetStorage *iface, IEnumSTATPROPSETSTG **enum_obj)
2955 {
2956 StorageImpl *storage = impl_from_IPropertySetStorage(iface);
2957
2958 TRACE("%p, %p.\n", iface, enum_obj);
2959
2960 if (!enum_obj)
2961 return E_INVALIDARG;
2962
2963 return create_enum_stat_propset_stg(storage, enum_obj);
2964 }
2965
2966 /***********************************************************************
2967 * vtables
2968 */
2969 const IPropertySetStorageVtbl IPropertySetStorage_Vtbl =
2970 {
2971 IPropertySetStorage_fnQueryInterface,
2972 IPropertySetStorage_fnAddRef,
2973 IPropertySetStorage_fnRelease,
2974 IPropertySetStorage_fnCreate,
2975 IPropertySetStorage_fnOpen,
2976 IPropertySetStorage_fnDelete,
2977 IPropertySetStorage_fnEnum
2978 };
2979
2980 static const IPropertyStorageVtbl IPropertyStorage_Vtbl =
2981 {
2982 IPropertyStorage_fnQueryInterface,
2983 IPropertyStorage_fnAddRef,
2984 IPropertyStorage_fnRelease,
2985 IPropertyStorage_fnReadMultiple,
2986 IPropertyStorage_fnWriteMultiple,
2987 IPropertyStorage_fnDeleteMultiple,
2988 IPropertyStorage_fnReadPropertyNames,
2989 IPropertyStorage_fnWritePropertyNames,
2990 IPropertyStorage_fnDeletePropertyNames,
2991 IPropertyStorage_fnCommit,
2992 IPropertyStorage_fnRevert,
2993 IPropertyStorage_fnEnum,
2994 IPropertyStorage_fnSetTimes,
2995 IPropertyStorage_fnSetClass,
2996 IPropertyStorage_fnStat,
2997 };
2998
2999 /***********************************************************************
3000 * Format ID <-> name conversion
3001 */
3002 static const WCHAR szSummaryInfo[] = L"\5SummaryInformation";
3003 static const WCHAR szDocSummaryInfo[] = L"\5DocumentSummaryInformation";
3004
3005 #define BITS_PER_BYTE 8
3006 #define CHARMASK 0x1f
3007 #define BITS_IN_CHARMASK 5
3008 #define NUM_ALPHA_CHARS 26
3009
3010 /***********************************************************************
3011 * FmtIdToPropStgName [ole32.@]
3012 * Returns the storage name of the format ID rfmtid.
3013 * PARAMS
3014 * rfmtid [I] Format ID for which to return a storage name
3015 * str [O] Storage name associated with rfmtid.
3016 *
3017 * RETURNS
3018 * E_INVALIDARG if rfmtid or str i NULL, S_OK otherwise.
3019 *
3020 * NOTES
3021 * str must be at least CCH_MAX_PROPSTG_NAME characters in length.
3022 */
3023 HRESULT WINAPI FmtIdToPropStgName(const FMTID *rfmtid, LPOLESTR str)
3024 {
3025 static const char fmtMap[] = "abcdefghijklmnopqrstuvwxyz012345";
3026
3027 TRACE("%s, %p\n", debugstr_guid(rfmtid), str);
3028
3029 if (!rfmtid) return E_INVALIDARG;
3030 if (!str) return E_INVALIDARG;
3031
3032 if (IsEqualGUID(&FMTID_SummaryInformation, rfmtid))
3033 lstrcpyW(str, szSummaryInfo);
3034 else if (IsEqualGUID(&FMTID_DocSummaryInformation, rfmtid))
3035 lstrcpyW(str, szDocSummaryInfo);
3036 else if (IsEqualGUID(&FMTID_UserDefinedProperties, rfmtid))
3037 lstrcpyW(str, szDocSummaryInfo);
3038 else
3039 {
3040 const BYTE *fmtptr;
3041 WCHAR *pstr = str;
3042 ULONG bitsRemaining = BITS_PER_BYTE;
3043
3044 *pstr++ = 5;
3045 for (fmtptr = (const BYTE *)rfmtid; fmtptr < (const BYTE *)rfmtid + sizeof(FMTID); )
3046 {
3047 ULONG i = *fmtptr >> (BITS_PER_BYTE - bitsRemaining);
3048
3049 if (bitsRemaining >= BITS_IN_CHARMASK)
3050 {
3051 *pstr = (WCHAR)(fmtMap[i & CHARMASK]);
3052 if (bitsRemaining == BITS_PER_BYTE && *pstr >= 'a' &&
3053 *pstr <= 'z')
3054 *pstr += 'A' - 'a';
3055 pstr++;
3056 bitsRemaining -= BITS_IN_CHARMASK;
3057 if (bitsRemaining == 0)
3058 {
3059 fmtptr++;
3060 bitsRemaining = BITS_PER_BYTE;
3061 }
3062 }
3063 else
3064 {
3065 if (++fmtptr < (const BYTE *)rfmtid + sizeof(FMTID))
3066 i |= *fmtptr << bitsRemaining;
3067 *pstr++ = (WCHAR)(fmtMap[i & CHARMASK]);
3068 bitsRemaining += BITS_PER_BYTE - BITS_IN_CHARMASK;
3069 }
3070 }
3071 *pstr = 0;
3072 }
3073 TRACE("returning %s\n", debugstr_w(str));
3074 return S_OK;
3075 }
3076
3077 /***********************************************************************
3078 * PropStgNameToFmtId [ole32.@]
3079 * Returns the format ID corresponding to the given name.
3080 * PARAMS
3081 * str [I] Storage name to convert to a format ID.
3082 * rfmtid [O] Format ID corresponding to str.
3083 *
3084 * RETURNS
3085 * E_INVALIDARG if rfmtid or str is NULL or if str can't be converted to
3086 * a format ID, S_OK otherwise.
3087 */
3088 HRESULT WINAPI PropStgNameToFmtId(const LPOLESTR str, FMTID *rfmtid)
3089 {
3090 HRESULT hr = STG_E_INVALIDNAME;
3091
3092 TRACE("%s, %p\n", debugstr_w(str), rfmtid);
3093
3094 if (!rfmtid) return E_INVALIDARG;
3095 if (!str) return STG_E_INVALIDNAME;
3096
3097 if (!lstrcmpiW(str, szDocSummaryInfo))
3098 {
3099 *rfmtid = FMTID_DocSummaryInformation;
3100 hr = S_OK;
3101 }
3102 else if (!lstrcmpiW(str, szSummaryInfo))
3103 {
3104 *rfmtid = FMTID_SummaryInformation;
3105 hr = S_OK;
3106 }
3107 else
3108 {
3109 ULONG bits;
3110 BYTE *fmtptr = (BYTE *)rfmtid - 1;
3111 const WCHAR *pstr = str;
3112
3113 memset(rfmtid, 0, sizeof(*rfmtid));
3114 for (bits = 0; bits < sizeof(FMTID) * BITS_PER_BYTE;
3115 bits += BITS_IN_CHARMASK)
3116 {
3117 ULONG bitsUsed = bits % BITS_PER_BYTE, bitsStored;
3118 WCHAR wc;
3119
3120 if (bitsUsed == 0)
3121 fmtptr++;
3122 wc = *++pstr - 'A';
3123 if (wc > NUM_ALPHA_CHARS)
3124 {
3125 wc += 'A' - 'a';
3126 if (wc > NUM_ALPHA_CHARS)
3127 {
3128 wc += 'a' - '0' + NUM_ALPHA_CHARS;
3129 if (wc > CHARMASK)
3130 {
3131 WARN("invalid character (%d)\n", *pstr);
3132 goto end;
3133 }
3134 }
3135 }
3136 *fmtptr |= wc << bitsUsed;
3137 bitsStored = min(BITS_PER_BYTE - bitsUsed, BITS_IN_CHARMASK);
3138 if (bitsStored < BITS_IN_CHARMASK)
3139 {
3140 wc >>= BITS_PER_BYTE - bitsUsed;
3141 if (bits + bitsStored == sizeof(FMTID) * BITS_PER_BYTE)
3142 {
3143 if (wc != 0)
3144 {
3145 WARN("extra bits\n");
3146 goto end;
3147 }
3148 break;
3149 }
3150 fmtptr++;
3151 *fmtptr |= (BYTE)wc;
3152 }
3153 }
3154 hr = S_OK;
3155 }
3156 end:
3157 return hr;
3158 }
3159
3160 #ifdef __i386__ /* thiscall functions are i386-specific */
3161
3162 #define DEFINE_STDCALL_WRAPPER(num,func,args) \
3163 __ASM_STDCALL_FUNC(func, args, \
3164 "popl %eax\n\t" \
3165 "popl %ecx\n\t" \
3166 "pushl %eax\n\t" \
3167 "movl (%ecx), %eax\n\t" \
3168 "jmp *(4*(" #num "))(%eax)" )
3169
3170 DEFINE_STDCALL_WRAPPER(0,Allocate_PMemoryAllocator,8)
3171 extern void* WINAPI Allocate_PMemoryAllocator(void *this, ULONG cbSize);
3172
3173 #else
3174
3175 static void* WINAPI Allocate_PMemoryAllocator(void *this, ULONG cbSize)
3176 {
3177 void* (WINAPI *fn)(void*,ULONG) = **(void***)this;
3178 return fn(this, cbSize);
3179 }
3180
3181 #endif
3182
3183 BOOLEAN WINAPI StgConvertPropertyToVariant(const SERIALIZEDPROPERTYVALUE* prop,
3184 USHORT CodePage, PROPVARIANT* pvar, void* pma)
3185 {
3186 struct read_buffer read_buffer;
3187 HRESULT hr;
3188
3189 read_buffer.data = (BYTE *)prop;
3190 read_buffer.size = ~(size_t)0;
3191 hr = PropertyStorage_ReadProperty(pvar, &read_buffer, 0, CodePage, Allocate_PMemoryAllocator, pma);
3192
3193 if (FAILED(hr))
3194 {
3195 FIXME("should raise C++ exception on failure\n");
3196 PropVariantInit(pvar);
3197 }
3198
3199 return FALSE;
3200 }
3201
3202 SERIALIZEDPROPERTYVALUE* WINAPI StgConvertVariantToProperty(const PROPVARIANT *pvar,
3203 USHORT CodePage, SERIALIZEDPROPERTYVALUE *pprop, ULONG *pcb, PROPID pid,
3204 BOOLEAN fReserved, ULONG *pcIndirect)
3205 {
3206 FIXME("%p, %d, %p, %p, %ld, %d, %p.\n", pvar, CodePage, pprop, pcb, pid, fReserved, pcIndirect);
3207
3208 return NULL;
3209 }
3210
3211 HRESULT WINAPI StgCreatePropStg(IUnknown *unk, REFFMTID fmt, const CLSID *clsid,
3212 DWORD flags, DWORD reserved, IPropertyStorage **prop_stg)
3213 {
3214 IStorage *stg;
3215 IStream *stm;
3216 HRESULT r;
3217
3218 TRACE("%p, %s, %s, %#lx, %ld, %p.\n", unk, debugstr_guid(fmt), debugstr_guid(clsid), flags, reserved, prop_stg);
3219
3220 if (!fmt || reserved)
3221 {
3222 r = E_INVALIDARG;
3223 goto end;
3224 }
3225
3226 if (flags & PROPSETFLAG_NONSIMPLE)
3227 {
3228 r = IUnknown_QueryInterface(unk, &IID_IStorage, (void **)&stg);
3229 if (FAILED(r))
3230 goto end;
3231
3232 /* FIXME: if (flags & PROPSETFLAG_NONSIMPLE), we need to create a
3233 * storage, not a stream. For now, disallow it.
3234 */
3235 FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
3236 IStorage_Release(stg);
3237 r = STG_E_INVALIDFLAG;
3238 }
3239 else
3240 {
3241 r = IUnknown_QueryInterface(unk, &IID_IStream, (void **)&stm);
3242 if (FAILED(r))
3243 goto end;
3244
3245 r = PropertyStorage_ConstructEmpty(stm, fmt, flags,
3246 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, prop_stg);
3247
3248 IStream_Release( stm );
3249 }
3250
3251 end:
3252 TRACE("returning %#lx\n", r);
3253 return r;
3254 }
3255
3256 HRESULT WINAPI StgOpenPropStg(IUnknown *unk, REFFMTID fmt, DWORD flags,
3257 DWORD reserved, IPropertyStorage **prop_stg)
3258 {
3259 IStorage *stg;
3260 IStream *stm;
3261 HRESULT r;
3262
3263 TRACE("%p, %s, %#lx, %ld, %p.\n", unk, debugstr_guid(fmt), flags, reserved, prop_stg);
3264
3265 if (!fmt || reserved)
3266 {
3267 r = E_INVALIDARG;
3268 goto end;
3269 }
3270
3271 if (flags & PROPSETFLAG_NONSIMPLE)
3272 {
3273 r = IUnknown_QueryInterface(unk, &IID_IStorage, (void **)&stg);
3274 if (FAILED(r))
3275 goto end;
3276
3277 /* FIXME: if (flags & PROPSETFLAG_NONSIMPLE), we need to open a
3278 * storage, not a stream. For now, disallow it.
3279 */
3280 FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
3281 IStorage_Release(stg);
3282 r = STG_E_INVALIDFLAG;
3283 }
3284 else
3285 {
3286 r = IUnknown_QueryInterface(unk, &IID_IStream, (void **)&stm);
3287 if (FAILED(r))
3288 goto end;
3289
3290 r = PropertyStorage_ConstructFromStream(stm, fmt,
3291 STGM_READWRITE|STGM_SHARE_EXCLUSIVE, prop_stg);
3292
3293 IStream_Release( stm );
3294 }
3295
3296 end:
3297 TRACE("returning %#lx\n", r);
3298 return r;
3299 }
Windows API implementation