?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Make sure __int64 is correctly defined on PPC64.
[wine.git] / dlls / ole32 / stg_prop.c
blob7b1cd801cf1f4edf8c772dfe1b7350dee0e523f2
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 %u.\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 %u.\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, %u, %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, %u.\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, %d, %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].u.iVal = This->codePage;
515 break;
516 case PID_LOCALE:
517 rgpropvar[i].vt = VT_I4;
518 rgpropvar[i].u.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 0x%08x (%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->u.pszVal, srcCP, &prop->u.pszVal, targetCP);
633 if (SUCCEEDED(hr))
634 prop->vt = VT_LPSTR;
635 break;
636 case VT_BSTR:
637 if ((prop->u.bstrVal = SysAllocStringLen(propvar->u.bstrVal, SysStringLen(propvar->u.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 0x%08x 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 %d\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, %d, %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 = rgpropvar[i].u.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].u.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, %d, %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, %d, %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, %d, %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, %d, %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, 0x%08x)\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("(%u, %u)\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->u.cVal);
1261 TRACE("Read char 0x%x ('%c')\n", prop->u.cVal, prop->u.cVal);
1262 break;
1263 case VT_UI1:
1264 hr = buffer_read_byte(buffer, offset, &prop->u.bVal);
1265 TRACE("Read byte 0x%x\n", prop->u.bVal);
1266 break;
1267 case VT_BOOL:
1268 hr = buffer_read_word(buffer, offset, (WORD *)&prop->u.boolVal);
1269 TRACE("Read bool %d\n", prop->u.boolVal);
1270 break;
1271 case VT_I2:
1272 hr = buffer_read_word(buffer, offset, (WORD *)&prop->u.iVal);
1273 TRACE("Read short %d\n", prop->u.iVal);
1274 break;
1275 case VT_UI2:
1276 hr = buffer_read_word(buffer, offset, &prop->u.uiVal);
1277 TRACE("Read ushort %d\n", prop->u.uiVal);
1278 break;
1279 case VT_INT:
1280 case VT_I4:
1281 hr = buffer_read_dword(buffer, offset, (DWORD *)&prop->u.lVal);
1282 TRACE("Read long %d\n", prop->u.lVal);
1283 break;
1284 case VT_UINT:
1285 case VT_UI4:
1286 hr = buffer_read_dword(buffer, offset, &prop->u.ulVal);
1287 TRACE("Read ulong %d\n", prop->u.ulVal);
1288 break;
1289 case VT_I8:
1290 hr = buffer_read_uint64(buffer, offset, (ULARGE_INTEGER *)&prop->u.hVal);
1291 TRACE("Read long long %s\n", wine_dbgstr_longlong(prop->u.hVal.QuadPart));
1292 break;
1293 case VT_UI8:
1294 hr = buffer_read_uint64(buffer, offset, &prop->u.uhVal);
1295 TRACE("Read ulong long %s\n", wine_dbgstr_longlong(prop->u.uhVal.QuadPart));
1296 break;
1297 case VT_R8:
1298 hr = buffer_read_len(buffer, offset, &prop->u.dblVal, sizeof(prop->u.dblVal));
1299 TRACE("Read double %f\n", prop->u.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->u.pszVal = allocate(allocate_data, count);
1318 if (prop->u.pszVal)
1319 {
1320 if (FAILED(hr = buffer_read_len(buffer, offset, prop->u.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->u.pszVal[count / sizeof(WCHAR) - 1] = '\0';
1330 TRACE("Read string value %s\n",
1331 debugstr_w(prop->u.pwszVal));
1332 }
1333 else
1334 {
1335 /* Make sure it's NULL-terminated */
1336 prop->u.pszVal[count - 1] = '\0';
1337 TRACE("Read string value %s\n", debugstr_a(prop->u.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->u.bstrVal = SysAllocStringLen(NULL, wcount); /* FIXME: use allocator? */
1371
1372 if (prop->u.bstrVal)
1373 {
1374 if (codepage == CP_UNICODE)
1375 hr = buffer_read_len(buffer, offset, prop->u.bstrVal, count);
1376 else
1377 MultiByteToWideChar(codepage, 0, (LPCSTR)(buffer->data + offset), count, prop->u.bstrVal, wcount);
1378
1379 prop->u.bstrVal[wcount - 1] = '\0';
1380 TRACE("Read string value %s\n", debugstr_w(prop->u.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->u.blob.cbSize = count;
1397 prop->u.blob.pBlobData = allocate(allocate_data, count);
1398 if (prop->u.blob.pBlobData)
1399 {
1400 hr = buffer_read_len(buffer, offset, prop->u.blob.pBlobData, count);
1401 TRACE("Read blob value of size %d\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->u.pwszVal = allocate(allocate_data, count * sizeof(WCHAR));
1417 if (prop->u.pwszVal)
1418 {
1419 if (SUCCEEDED(hr = buffer_read_len(buffer, offset, prop->u.pwszVal, count * sizeof(WCHAR))))
1420 {
1421 /* make sure string is NULL-terminated */
1422 prop->u.pwszVal[count - 1] = '\0';
1423 PropertyStorage_ByteSwapString(prop->u.pwszVal, count);
1424 TRACE("Read string value %s\n", debugstr_w(prop->u.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->u.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->u.pclipdata = allocate(allocate_data, sizeof (CLIPDATA));
1449 prop->u.pclipdata->cbSize = len;
1450 prop->u.pclipdata->ulClipFmt = tag;
1451 prop->u.pclipdata->pClipData = allocate(allocate_data, len - sizeof(prop->u.pclipdata->ulClipFmt));
1452 hr = buffer_read_len(buffer, offset, prop->u.pclipdata->pClipData, len - sizeof(prop->u.pclipdata->ulClipFmt));
1453 }
1454 else
1455 hr = STG_E_INVALIDPARAMETER;
1456 }
1457 break;
1458 case VT_CLSID:
1459 if (!(prop->u.puuid = allocate(allocate_data, sizeof (*prop->u.puuid))))
1460 return STG_E_INSUFFICIENTMEMORY;
1461
1462 if (SUCCEEDED(hr = buffer_test_offset(buffer, offset, sizeof(*prop->u.puuid))))
1463 StorageUtl_ReadGUID(buffer->data, offset, prop->u.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->u.cac.pElems);
1482 case VT_UI1: return sizeof(*prop->u.caub.pElems);
1483 case VT_I2: return sizeof(*prop->u.cai.pElems);
1484 case VT_UI2: return sizeof(*prop->u.caui.pElems);
1485 case VT_BOOL: return sizeof(*prop->u.cabool.pElems);
1486 case VT_I4: return sizeof(*prop->u.cal.pElems);
1487 case VT_UI4: return sizeof(*prop->u.caul.pElems);
1488 case VT_R4: return sizeof(*prop->u.caflt.pElems);
1489 case VT_ERROR: return sizeof(*prop->u.cascode.pElems);
1490 case VT_I8: return sizeof(*prop->u.cah.pElems);
1491 case VT_UI8: return sizeof(*prop->u.cauh.pElems);
1492 case VT_R8: return sizeof(*prop->u.cadbl.pElems);
1493 case VT_CY: return sizeof(*prop->u.cacy.pElems);
1494 case VT_DATE: return sizeof(*prop->u.cadate.pElems);
1495 case VT_FILETIME: return sizeof(*prop->u.cafiletime.pElems);
1496 case VT_CLSID: return sizeof(*prop->u.cauuid.pElems);
1497 case VT_VARIANT: return sizeof(*prop->u.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->u.capropvar.pElems = allocate(allocate_data, elemsize * count)))
1544 {
1545 prop->u.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->u.capropvar.pElems[i], &elem.u.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 %d\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 0x%08x\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 %d\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 0x%08x\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 %d\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 0x%08x\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 %d 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 %d.\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 %d is not null-terminated.\n", i);
1713 return E_FAIL;
1714 }
1715
1716 TRACE("Reading entry with ID %#x, %d 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 %d (stream length is %d)\n", fmtOffset.dwOffset,
1800 stat.cbSize.u.LowPart);
1801 hr = STG_E_INVALIDHEADER;
1802 goto end;
1803 }
1804 /* wackiness alert: if the format ID is FMTID_DocSummaryInformation, there
1805 * follows not one, but two sections. The first contains the standard properties
1806 * for the document summary information, and the second consists of user-defined
1807 * properties. This is the only case in which multiple sections are
1808 * allowed.
1809 * Reading the second stream isn't implemented yet.
1810 */
1811 hr = PropertyStorage_ReadSectionHeaderFromStream(This->stm, &sectionHdr);
1812 if (FAILED(hr))
1813 goto end;
1814 /* The section size includes the section header, so check it */
1815 if (sectionHdr.cbSection < sizeof(PROPERTYSECTIONHEADER))
1816 {
1817 WARN("section header too small, got %d\n", sectionHdr.cbSection);
1818 hr = STG_E_INVALIDHEADER;
1819 goto end;
1820 }
1821 buf = HeapAlloc(GetProcessHeap(), 0, sectionHdr.cbSection -
1822 sizeof(PROPERTYSECTIONHEADER));
1823 if (!buf)
1824 {
1825 hr = STG_E_INSUFFICIENTMEMORY;
1826 goto end;
1827 }
1828 read_buffer.data = buf;
1829 read_buffer.size = sectionHdr.cbSection - sizeof(sectionHdr);
1830
1831 hr = IStream_Read(This->stm, read_buffer.data, read_buffer.size, &count);
1832 if (FAILED(hr))
1833 goto end;
1834 TRACE("Reading %d properties:\n", sectionHdr.cProperties);
1835 for (i = 0; SUCCEEDED(hr) && i < sectionHdr.cProperties; i++)
1836 {
1837 PROPERTYIDOFFSET *idOffset = (PROPERTYIDOFFSET *)(read_buffer.data +
1838 i * sizeof(PROPERTYIDOFFSET));
1839
1840 if (idOffset->dwOffset < sizeof(PROPERTYSECTIONHEADER) ||
1841 idOffset->dwOffset > sectionHdr.cbSection - sizeof(DWORD))
1842 hr = STG_E_INVALIDPOINTER;
1843 else
1844 {
1845 if (idOffset->propid >= PID_FIRST_USABLE &&
1846 idOffset->propid < PID_MIN_READONLY && idOffset->propid >
1847 This->highestProp)
1848 This->highestProp = idOffset->propid;
1849 if (idOffset->propid == PID_DICTIONARY)
1850 {
1851 /* Don't read the dictionary yet, its entries depend on the
1852 * code page. Just store the offset so we know to read it
1853 * later.
1854 */
1855 dictOffset = idOffset->dwOffset;
1856 TRACE("Dictionary offset is %d\n", dictOffset);
1857 }
1858 else
1859 {
1860 PROPVARIANT prop;
1861
1862 PropVariantInit(&prop);
1863 if (SUCCEEDED(PropertyStorage_ReadProperty(&prop, &read_buffer,
1864 idOffset->dwOffset - sizeof(PROPERTYSECTIONHEADER), This->codePage,
1865 Allocate_CoTaskMemAlloc, NULL)))
1866 {
1867 TRACE("Read property with ID 0x%08x, type %d\n",
1868 idOffset->propid, prop.vt);
1869 switch(idOffset->propid)
1870 {
1871 case PID_CODEPAGE:
1872 if (prop.vt == VT_I2)
1873 This->codePage = (UINT)prop.u.iVal;
1874 break;
1875 case PID_LOCALE:
1876 if (prop.vt == VT_I4)
1877 This->locale = (LCID)prop.u.lVal;
1878 break;
1879 case PID_BEHAVIOR:
1880 if (prop.vt == VT_I4 && prop.u.lVal)
1881 This->grfFlags |= PROPSETFLAG_CASE_SENSITIVE;
1882 /* The format should already be 1, but just in case */
1883 This->format = 1;
1884 break;
1885 default:
1886 hr = PropertyStorage_StorePropWithId(This,
1887 idOffset->propid, &prop, This->codePage);
1888 }
1889 }
1890 PropVariantClear(&prop);
1891 }
1892 }
1893 }
1894 if (!This->codePage)
1895 {
1896 /* default to Unicode unless told not to, as specified on msdn */
1897 if (This->grfFlags & PROPSETFLAG_ANSI)
1898 This->codePage = GetACP();
1899 else
1900 This->codePage = CP_UNICODE;
1901 }
1902 if (!This->locale)
1903 This->locale = LOCALE_SYSTEM_DEFAULT;
1904 TRACE("Code page is %d, locale is %d\n", This->codePage, This->locale);
1905 if (dictOffset)
1906 hr = PropertyStorage_ReadDictionary(This, &read_buffer, dictOffset - sizeof(PROPERTYSECTIONHEADER));
1907
1908 end:
1909 HeapFree(GetProcessHeap(), 0, buf);
1910 if (FAILED(hr))
1911 {
1912 dictionary_destroy(This->name_to_propid);
1913 This->name_to_propid = NULL;
1914 dictionary_destroy(This->propid_to_name);
1915 This->propid_to_name = NULL;
1916 dictionary_destroy(This->propid_to_prop);
1917 This->propid_to_prop = NULL;
1918 }
1919 return hr;
1920 }
1921
1922 static void PropertyStorage_MakeHeader(PropertyStorage_impl *This,
1923 PROPERTYSETHEADER *hdr)
1924 {
1925 assert(hdr);
1926 StorageUtl_WriteWord(&hdr->wByteOrder, 0, PROPSETHDR_BYTEORDER_MAGIC);
1927 StorageUtl_WriteWord(&hdr->wFormat, 0, This->format);
1928 StorageUtl_WriteDWord(&hdr->dwOSVer, 0, This->originatorOS);
1929 StorageUtl_WriteGUID(&hdr->clsid, 0, &This->clsid);
1930 StorageUtl_WriteDWord(&hdr->reserved, 0, 1);
1931 }
1932
1933 static void PropertyStorage_MakeFmtIdOffset(PropertyStorage_impl *This,
1934 FORMATIDOFFSET *fmtOffset)
1935 {
1936 assert(fmtOffset);
1937 StorageUtl_WriteGUID(fmtOffset, 0, &This->fmtid);
1938 StorageUtl_WriteDWord(fmtOffset, offsetof(FORMATIDOFFSET, dwOffset),
1939 sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET));
1940 }
1941
1942 static void PropertyStorage_MakeSectionHdr(DWORD cbSection, DWORD numProps,
1943 PROPERTYSECTIONHEADER *hdr)
1944 {
1945 assert(hdr);
1946 StorageUtl_WriteDWord(hdr, 0, cbSection);
1947 StorageUtl_WriteDWord(hdr, offsetof(PROPERTYSECTIONHEADER, cProperties), numProps);
1948 }
1949
1950 static void PropertyStorage_MakePropertyIdOffset(DWORD propid, DWORD dwOffset,
1951 PROPERTYIDOFFSET *propIdOffset)
1952 {
1953 assert(propIdOffset);
1954 StorageUtl_WriteDWord(propIdOffset, 0, propid);
1955 StorageUtl_WriteDWord(propIdOffset, offsetof(PROPERTYIDOFFSET, dwOffset), dwOffset);
1956 }
1957
1958 static inline HRESULT PropertyStorage_WriteWStringToStream(IStream *stm,
1959 LPCWSTR str, DWORD len, DWORD *written)
1960 {
1961 #ifdef WORDS_BIGENDIAN
1962 WCHAR *leStr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1963 HRESULT hr;
1964
1965 if (!leStr)
1966 return E_OUTOFMEMORY;
1967 memcpy(leStr, str, len * sizeof(WCHAR));
1968 PropertyStorage_ByteSwapString(leStr, len);
1969 hr = IStream_Write(stm, leStr, len, written);
1970 HeapFree(GetProcessHeap(), 0, leStr);
1971 return hr;
1972 #else
1973 return IStream_Write(stm, str, len * sizeof(WCHAR), written);
1974 #endif
1975 }
1976
1977 struct DictionaryClosure
1978 {
1979 HRESULT hr;
1980 DWORD bytesWritten;
1981 };
1982
1983 static BOOL PropertyStorage_DictionaryWriter(const void *key,
1984 const void *value, void *extra, void *closure)
1985 {
1986 PropertyStorage_impl *This = extra;
1987 struct DictionaryClosure *c = closure;
1988 DWORD propid, keyLen;
1989 ULONG count;
1990
1991 assert(key);
1992 assert(closure);
1993 StorageUtl_WriteDWord(&propid, 0, PtrToUlong(value));
1994 c->hr = IStream_Write(This->stm, &propid, sizeof(propid), &count);
1995 if (FAILED(c->hr))
1996 goto end;
1997 c->bytesWritten += sizeof(DWORD);
1998 if (This->codePage == CP_UNICODE)
1999 {
2000 DWORD pad = 0, pad_len;
2001
2002 StorageUtl_WriteDWord(&keyLen, 0, lstrlenW((LPCWSTR)key) + 1);
2003 c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
2004 if (FAILED(c->hr))
2005 goto end;
2006 c->bytesWritten += sizeof(DWORD);
2007 c->hr = PropertyStorage_WriteWStringToStream(This->stm, key, keyLen,
2008 &count);
2009 if (FAILED(c->hr))
2010 goto end;
2011 keyLen *= sizeof(WCHAR);
2012 c->bytesWritten += keyLen;
2013
2014 /* Align to 4 bytes. */
2015 pad_len = sizeof(DWORD) - keyLen % sizeof(DWORD);
2016 if (pad_len)
2017 {
2018 c->hr = IStream_Write(This->stm, &pad, pad_len, &count);
2019 if (FAILED(c->hr))
2020 goto end;
2021 c->bytesWritten += pad_len;
2022 }
2023 }
2024 else
2025 {
2026 StorageUtl_WriteDWord(&keyLen, 0, strlen((LPCSTR)key) + 1);
2027 c->hr = IStream_Write(This->stm, &keyLen, sizeof(keyLen), &count);
2028 if (FAILED(c->hr))
2029 goto end;
2030 c->bytesWritten += sizeof(DWORD);
2031 c->hr = IStream_Write(This->stm, key, keyLen, &count);
2032 if (FAILED(c->hr))
2033 goto end;
2034 c->bytesWritten += keyLen;
2035 }
2036 end:
2037 return SUCCEEDED(c->hr);
2038 }
2039
2040 #define SECTIONHEADER_OFFSET sizeof(PROPERTYSETHEADER) + sizeof(FORMATIDOFFSET)
2041
2042 /* Writes the dictionary to the stream. Assumes without checking that the
2043 * dictionary isn't empty.
2044 */
2045 static HRESULT PropertyStorage_WriteDictionaryToStream(
2046 PropertyStorage_impl *This, DWORD *sectionOffset)
2047 {
2048 HRESULT hr;
2049 LARGE_INTEGER seek;
2050 PROPERTYIDOFFSET propIdOffset;
2051 ULONG count;
2052 DWORD dwTemp;
2053 struct DictionaryClosure closure;
2054
2055 assert(sectionOffset);
2056
2057 /* The dictionary's always the first property written, so seek to its
2058 * spot.
2059 */
2060 seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER);
2061 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2062 if (FAILED(hr))
2063 goto end;
2064 PropertyStorage_MakePropertyIdOffset(PID_DICTIONARY, *sectionOffset,
2065 &propIdOffset);
2066 hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
2067 if (FAILED(hr))
2068 goto end;
2069
2070 seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
2071 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2072 if (FAILED(hr))
2073 goto end;
2074 StorageUtl_WriteDWord(&dwTemp, 0, dictionary_num_entries(This->name_to_propid));
2075 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2076 if (FAILED(hr))
2077 goto end;
2078 *sectionOffset += sizeof(dwTemp);
2079
2080 closure.hr = S_OK;
2081 closure.bytesWritten = 0;
2082 dictionary_enumerate(This->name_to_propid, PropertyStorage_DictionaryWriter,
2083 &closure);
2084 hr = closure.hr;
2085 if (FAILED(hr))
2086 goto end;
2087 *sectionOffset += closure.bytesWritten;
2088 if (closure.bytesWritten % sizeof(DWORD))
2089 {
2090 DWORD padding = sizeof(DWORD) - closure.bytesWritten % sizeof(DWORD);
2091 TRACE("adding %d bytes of padding\n", padding);
2092 *sectionOffset += padding;
2093 }
2094
2095 end:
2096 return hr;
2097 }
2098
2099 static HRESULT PropertyStorage_WritePropertyToStream(PropertyStorage_impl *This,
2100 DWORD propNum, DWORD propid, const PROPVARIANT *var, DWORD *sectionOffset)
2101 {
2102 DWORD len, dwType, dwTemp, bytesWritten;
2103 HRESULT hr;
2104 LARGE_INTEGER seek;
2105 PROPERTYIDOFFSET propIdOffset;
2106 ULARGE_INTEGER ularge;
2107 ULONG count;
2108
2109 assert(var);
2110 assert(sectionOffset);
2111
2112 TRACE("%p, %d, 0x%08x, (%d), (%d)\n", This, propNum, propid, var->vt,
2113 *sectionOffset);
2114
2115 seek.QuadPart = SECTIONHEADER_OFFSET + sizeof(PROPERTYSECTIONHEADER) +
2116 propNum * sizeof(PROPERTYIDOFFSET);
2117 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2118 if (FAILED(hr))
2119 goto end;
2120 PropertyStorage_MakePropertyIdOffset(propid, *sectionOffset, &propIdOffset);
2121 hr = IStream_Write(This->stm, &propIdOffset, sizeof(propIdOffset), &count);
2122 if (FAILED(hr))
2123 goto end;
2124
2125 seek.QuadPart = SECTIONHEADER_OFFSET + *sectionOffset;
2126 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2127 if (FAILED(hr))
2128 goto end;
2129 StorageUtl_WriteDWord(&dwType, 0, var->vt);
2130 hr = IStream_Write(This->stm, &dwType, sizeof(dwType), &count);
2131 if (FAILED(hr))
2132 goto end;
2133 *sectionOffset += sizeof(dwType);
2134
2135 switch (var->vt)
2136 {
2137 case VT_EMPTY:
2138 case VT_NULL:
2139 bytesWritten = 0;
2140 break;
2141 case VT_I1:
2142 case VT_UI1:
2143 hr = IStream_Write(This->stm, &var->u.cVal, sizeof(var->u.cVal),
2144 &count);
2145 bytesWritten = count;
2146 break;
2147 case VT_I2:
2148 case VT_UI2:
2149 {
2150 WORD wTemp;
2151
2152 StorageUtl_WriteWord(&wTemp, 0, var->u.iVal);
2153 hr = IStream_Write(This->stm, &wTemp, sizeof(wTemp), &count);
2154 bytesWritten = count;
2155 break;
2156 }
2157 case VT_I4:
2158 case VT_UI4:
2159 {
2160 StorageUtl_WriteDWord(&dwTemp, 0, var->u.lVal);
2161 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2162 bytesWritten = count;
2163 break;
2164 }
2165 case VT_I8:
2166 case VT_UI8:
2167 {
2168 StorageUtl_WriteULargeInteger(&ularge, 0, &var->u.uhVal);
2169 hr = IStream_Write(This->stm, &ularge, sizeof(ularge), &bytesWritten);
2170 break;
2171 }
2172 case VT_LPSTR:
2173 {
2174 if (This->codePage == CP_UNICODE)
2175 len = (lstrlenW(var->u.pwszVal) + 1) * sizeof(WCHAR);
2176 else
2177 len = lstrlenA(var->u.pszVal) + 1;
2178 StorageUtl_WriteDWord(&dwTemp, 0, len);
2179 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2180 if (FAILED(hr))
2181 goto end;
2182 hr = IStream_Write(This->stm, var->u.pszVal, len, &count);
2183 bytesWritten = count + sizeof(DWORD);
2184 break;
2185 }
2186 case VT_BSTR:
2187 {
2188 if (This->codePage == CP_UNICODE)
2189 {
2190 len = SysStringByteLen(var->u.bstrVal) + sizeof(WCHAR);
2191 StorageUtl_WriteDWord(&dwTemp, 0, len);
2192 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2193 if (SUCCEEDED(hr))
2194 hr = IStream_Write(This->stm, var->u.bstrVal, len, &count);
2195 }
2196 else
2197 {
2198 char *str;
2199
2200 len = WideCharToMultiByte(This->codePage, 0, var->u.bstrVal, SysStringLen(var->u.bstrVal) + 1,
2201 NULL, 0, NULL, NULL);
2202
2203 str = heap_alloc(len);
2204 if (!str)
2205 {
2206 hr = E_OUTOFMEMORY;
2207 goto end;
2208 }
2209
2210 WideCharToMultiByte(This->codePage, 0, var->u.bstrVal, SysStringLen(var->u.bstrVal),
2211 str, len, NULL, NULL);
2212 StorageUtl_WriteDWord(&dwTemp, 0, len);
2213 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2214 if (SUCCEEDED(hr))
2215 hr = IStream_Write(This->stm, str, len, &count);
2216 heap_free(str);
2217 }
2218
2219 bytesWritten = count + sizeof(DWORD);
2220 break;
2221 }
2222 case VT_LPWSTR:
2223 {
2224 len = lstrlenW(var->u.pwszVal) + 1;
2225
2226 StorageUtl_WriteDWord(&dwTemp, 0, len);
2227 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2228 if (FAILED(hr))
2229 goto end;
2230 hr = IStream_Write(This->stm, var->u.pwszVal, len * sizeof(WCHAR),
2231 &count);
2232 bytesWritten = count + sizeof(DWORD);
2233 break;
2234 }
2235 case VT_FILETIME:
2236 {
2237 FILETIME temp;
2238
2239 StorageUtl_WriteULargeInteger(&temp, 0, (const ULARGE_INTEGER *)&var->u.filetime);
2240 hr = IStream_Write(This->stm, &temp, sizeof(temp), &count);
2241 bytesWritten = count;
2242 break;
2243 }
2244 case VT_CF:
2245 {
2246 DWORD cf_hdr[2];
2247
2248 len = var->u.pclipdata->cbSize;
2249 StorageUtl_WriteDWord(&cf_hdr[0], 0, len + 8);
2250 StorageUtl_WriteDWord(&cf_hdr[1], 0, var->u.pclipdata->ulClipFmt);
2251 hr = IStream_Write(This->stm, cf_hdr, sizeof(cf_hdr), &count);
2252 if (FAILED(hr))
2253 goto end;
2254 hr = IStream_Write(This->stm, var->u.pclipdata->pClipData,
2255 len - sizeof(var->u.pclipdata->ulClipFmt), &count);
2256 if (FAILED(hr))
2257 goto end;
2258 bytesWritten = count + sizeof cf_hdr;
2259 break;
2260 }
2261 case VT_CLSID:
2262 {
2263 CLSID temp;
2264
2265 StorageUtl_WriteGUID(&temp, 0, var->u.puuid);
2266 hr = IStream_Write(This->stm, &temp, sizeof(temp), &count);
2267 bytesWritten = count;
2268 break;
2269 }
2270 default:
2271 FIXME("unsupported type: %d\n", var->vt);
2272 return STG_E_INVALIDPARAMETER;
2273 }
2274
2275 if (SUCCEEDED(hr))
2276 {
2277 *sectionOffset += bytesWritten;
2278 if (bytesWritten % sizeof(DWORD))
2279 {
2280 DWORD padding = sizeof(DWORD) - bytesWritten % sizeof(DWORD);
2281 TRACE("adding %d bytes of padding\n", padding);
2282 *sectionOffset += padding;
2283 }
2284 }
2285
2286 end:
2287 return hr;
2288 }
2289
2290 struct PropertyClosure
2291 {
2292 HRESULT hr;
2293 DWORD propNum;
2294 DWORD *sectionOffset;
2295 };
2296
2297 static BOOL PropertyStorage_PropertiesWriter(const void *key, const void *value,
2298 void *extra, void *closure)
2299 {
2300 PropertyStorage_impl *This = extra;
2301 struct PropertyClosure *c = closure;
2302
2303 assert(key);
2304 assert(value);
2305 assert(extra);
2306 assert(closure);
2307 c->hr = PropertyStorage_WritePropertyToStream(This, c->propNum++,
2308 PtrToUlong(key), value, c->sectionOffset);
2309 return SUCCEEDED(c->hr);
2310 }
2311
2312 static HRESULT PropertyStorage_WritePropertiesToStream(
2313 PropertyStorage_impl *This, DWORD startingPropNum, DWORD *sectionOffset)
2314 {
2315 struct PropertyClosure closure;
2316
2317 assert(sectionOffset);
2318 closure.hr = S_OK;
2319 closure.propNum = startingPropNum;
2320 closure.sectionOffset = sectionOffset;
2321 dictionary_enumerate(This->propid_to_prop, PropertyStorage_PropertiesWriter,
2322 &closure);
2323 return closure.hr;
2324 }
2325
2326 static HRESULT PropertyStorage_WriteHeadersToStream(PropertyStorage_impl *This)
2327 {
2328 HRESULT hr;
2329 ULONG count = 0;
2330 LARGE_INTEGER seek = { {0} };
2331 PROPERTYSETHEADER hdr;
2332 FORMATIDOFFSET fmtOffset;
2333
2334 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2335 if (FAILED(hr))
2336 goto end;
2337 PropertyStorage_MakeHeader(This, &hdr);
2338 hr = IStream_Write(This->stm, &hdr, sizeof(hdr), &count);
2339 if (FAILED(hr))
2340 goto end;
2341 if (count != sizeof(hdr))
2342 {
2343 hr = STG_E_WRITEFAULT;
2344 goto end;
2345 }
2346
2347 PropertyStorage_MakeFmtIdOffset(This, &fmtOffset);
2348 hr = IStream_Write(This->stm, &fmtOffset, sizeof(fmtOffset), &count);
2349 if (FAILED(hr))
2350 goto end;
2351 if (count != sizeof(fmtOffset))
2352 {
2353 hr = STG_E_WRITEFAULT;
2354 goto end;
2355 }
2356 hr = S_OK;
2357
2358 end:
2359 return hr;
2360 }
2361
2362 static HRESULT PropertyStorage_WriteToStream(PropertyStorage_impl *This)
2363 {
2364 PROPERTYSECTIONHEADER sectionHdr;
2365 HRESULT hr;
2366 ULONG count;
2367 LARGE_INTEGER seek;
2368 DWORD numProps, prop, sectionOffset, dwTemp;
2369 PROPVARIANT var;
2370
2371 PropertyStorage_WriteHeadersToStream(This);
2372
2373 /* Count properties. Always at least one property, the code page */
2374 numProps = 1;
2375 if (dictionary_num_entries(This->name_to_propid))
2376 numProps++;
2377 if (This->locale != LOCALE_SYSTEM_DEFAULT)
2378 numProps++;
2379 if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
2380 numProps++;
2381 numProps += dictionary_num_entries(This->propid_to_prop);
2382
2383 /* Write section header with 0 bytes right now, I'll adjust it after
2384 * writing properties.
2385 */
2386 PropertyStorage_MakeSectionHdr(0, numProps, &sectionHdr);
2387 seek.QuadPart = SECTIONHEADER_OFFSET;
2388 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2389 if (FAILED(hr))
2390 goto end;
2391 hr = IStream_Write(This->stm, &sectionHdr, sizeof(sectionHdr), &count);
2392 if (FAILED(hr))
2393 goto end;
2394
2395 prop = 0;
2396 sectionOffset = sizeof(PROPERTYSECTIONHEADER) +
2397 numProps * sizeof(PROPERTYIDOFFSET);
2398
2399 if (dictionary_num_entries(This->name_to_propid))
2400 {
2401 prop++;
2402 hr = PropertyStorage_WriteDictionaryToStream(This, &sectionOffset);
2403 if (FAILED(hr))
2404 goto end;
2405 }
2406
2407 PropVariantInit(&var);
2408
2409 var.vt = VT_I2;
2410 var.u.iVal = This->codePage;
2411 hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_CODEPAGE,
2412 &var, &sectionOffset);
2413 if (FAILED(hr))
2414 goto end;
2415
2416 if (This->locale != LOCALE_SYSTEM_DEFAULT)
2417 {
2418 var.vt = VT_I4;
2419 var.u.lVal = This->locale;
2420 hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_LOCALE,
2421 &var, &sectionOffset);
2422 if (FAILED(hr))
2423 goto end;
2424 }
2425
2426 if (This->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
2427 {
2428 var.vt = VT_I4;
2429 var.u.lVal = 1;
2430 hr = PropertyStorage_WritePropertyToStream(This, prop++, PID_BEHAVIOR,
2431 &var, &sectionOffset);
2432 if (FAILED(hr))
2433 goto end;
2434 }
2435
2436 hr = PropertyStorage_WritePropertiesToStream(This, prop, &sectionOffset);
2437 if (FAILED(hr))
2438 goto end;
2439
2440 /* Now write the byte count of the section */
2441 seek.QuadPart = SECTIONHEADER_OFFSET;
2442 hr = IStream_Seek(This->stm, seek, STREAM_SEEK_SET, NULL);
2443 if (FAILED(hr))
2444 goto end;
2445 StorageUtl_WriteDWord(&dwTemp, 0, sectionOffset);
2446 hr = IStream_Write(This->stm, &dwTemp, sizeof(dwTemp), &count);
2447
2448 end:
2449 return hr;
2450 }
2451
2452 /***********************************************************************
2453 * PropertyStorage_Construct
2454 */
2455 static void PropertyStorage_DestroyDictionaries(PropertyStorage_impl *This)
2456 {
2457 dictionary_destroy(This->name_to_propid);
2458 This->name_to_propid = NULL;
2459 dictionary_destroy(This->propid_to_name);
2460 This->propid_to_name = NULL;
2461 dictionary_destroy(This->propid_to_prop);
2462 This->propid_to_prop = NULL;
2463 }
2464
2465 static HRESULT PropertyStorage_CreateDictionaries(PropertyStorage_impl *This)
2466 {
2467 HRESULT hr = S_OK;
2468
2469 This->name_to_propid = dictionary_create(
2470 PropertyStorage_PropNameCompare, PropertyStorage_PropNameDestroy,
2471 This);
2472 if (!This->name_to_propid)
2473 {
2474 hr = STG_E_INSUFFICIENTMEMORY;
2475 goto end;
2476 }
2477 This->propid_to_name = dictionary_create(PropertyStorage_PropCompare,
2478 NULL, This);
2479 if (!This->propid_to_name)
2480 {
2481 hr = STG_E_INSUFFICIENTMEMORY;
2482 goto end;
2483 }
2484 This->propid_to_prop = dictionary_create(PropertyStorage_PropCompare,
2485 PropertyStorage_PropertyDestroy, This);
2486 if (!This->propid_to_prop)
2487 {
2488 hr = STG_E_INSUFFICIENTMEMORY;
2489 goto end;
2490 }
2491 end:
2492 if (FAILED(hr))
2493 PropertyStorage_DestroyDictionaries(This);
2494 return hr;
2495 }
2496
2497 static HRESULT PropertyStorage_BaseConstruct(IStream *stm,
2498 REFFMTID rfmtid, DWORD grfMode, PropertyStorage_impl **pps)
2499 {
2500 HRESULT hr = S_OK;
2501
2502 assert(pps);
2503 assert(rfmtid);
2504 *pps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof **pps);
2505 if (!*pps)
2506 return E_OUTOFMEMORY;
2507
2508 (*pps)->IPropertyStorage_iface.lpVtbl = &IPropertyStorage_Vtbl;
2509 (*pps)->ref = 1;
2510 InitializeCriticalSection(&(*pps)->cs);
2511 (*pps)->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PropertyStorage_impl.cs");
2512 (*pps)->stm = stm;
2513 (*pps)->fmtid = *rfmtid;
2514 (*pps)->grfMode = grfMode;
2515
2516 hr = PropertyStorage_CreateDictionaries(*pps);
2517 if (FAILED(hr))
2518 {
2519 (*pps)->cs.DebugInfo->Spare[0] = 0;
2520 DeleteCriticalSection(&(*pps)->cs);
2521 HeapFree(GetProcessHeap(), 0, *pps);
2522 *pps = NULL;
2523 }
2524 else IStream_AddRef( stm );
2525
2526 return hr;
2527 }
2528
2529 static HRESULT PropertyStorage_ConstructFromStream(IStream *stm,
2530 REFFMTID rfmtid, DWORD grfMode, IPropertyStorage** pps)
2531 {
2532 PropertyStorage_impl *ps;
2533 HRESULT hr;
2534
2535 assert(pps);
2536 hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
2537 if (SUCCEEDED(hr))
2538 {
2539 hr = PropertyStorage_ReadFromStream(ps);
2540 if (SUCCEEDED(hr))
2541 {
2542 *pps = &ps->IPropertyStorage_iface;
2543 TRACE("PropertyStorage %p constructed\n", ps);
2544 hr = S_OK;
2545 }
2546 else IPropertyStorage_Release( &ps->IPropertyStorage_iface );
2547 }
2548 return hr;
2549 }
2550
2551 static HRESULT PropertyStorage_ConstructEmpty(IStream *stm,
2552 REFFMTID rfmtid, DWORD grfFlags, DWORD grfMode, IPropertyStorage** pps)
2553 {
2554 PropertyStorage_impl *ps;
2555 HRESULT hr;
2556
2557 assert(pps);
2558 hr = PropertyStorage_BaseConstruct(stm, rfmtid, grfMode, &ps);
2559 if (SUCCEEDED(hr))
2560 {
2561 ps->format = 0;
2562 ps->grfFlags = grfFlags;
2563 if (ps->grfFlags & PROPSETFLAG_CASE_SENSITIVE)
2564 ps->format = 1;
2565 /* default to Unicode unless told not to, as specified on msdn */
2566 if (ps->grfFlags & PROPSETFLAG_ANSI)
2567 ps->codePage = GetACP();
2568 else
2569 ps->codePage = CP_UNICODE;
2570 ps->locale = LOCALE_SYSTEM_DEFAULT;
2571 TRACE("Code page is %d, locale is %d\n", ps->codePage, ps->locale);
2572 *pps = &ps->IPropertyStorage_iface;
2573 TRACE("PropertyStorage %p constructed\n", ps);
2574 hr = S_OK;
2575 }
2576 return hr;
2577 }
2578
2579
2580 /***********************************************************************
2581 * Implementation of IPropertySetStorage
2582 */
2583
2584 struct enum_stat_propset_stg
2585 {
2586 IEnumSTATPROPSETSTG IEnumSTATPROPSETSTG_iface;
2587 LONG refcount;
2588 STATPROPSETSTG *stats;
2589 size_t current;
2590 size_t count;
2591 };
2592
2593 static struct enum_stat_propset_stg *impl_from_IEnumSTATPROPSETSTG(IEnumSTATPROPSETSTG *iface)
2594 {
2595 return CONTAINING_RECORD(iface, struct enum_stat_propset_stg, IEnumSTATPROPSETSTG_iface);
2596 }
2597
2598 static HRESULT WINAPI enum_stat_propset_stg_QueryInterface(IEnumSTATPROPSETSTG *iface, REFIID riid, void **obj)
2599 {
2600 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2601
2602 if (IsEqualIID(riid, &IID_IEnumSTATPROPSETSTG) ||
2603 IsEqualIID(riid, &IID_IUnknown))
2604 {
2605 *obj = iface;
2606 IEnumSTATPROPSETSTG_AddRef(iface);
2607 return S_OK;
2608 }
2609
2610 WARN("Unsupported interface %s.\n", debugstr_guid(riid));
2611 return E_NOINTERFACE;
2612 }
2613
2614 static ULONG WINAPI enum_stat_propset_stg_AddRef(IEnumSTATPROPSETSTG *iface)
2615 {
2616 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2617 LONG refcount = InterlockedIncrement(&psenum->refcount);
2618
2619 TRACE("%p, refcount %u.\n", iface, refcount);
2620
2621 return refcount;
2622 }
2623
2624 static ULONG WINAPI enum_stat_propset_stg_Release(IEnumSTATPROPSETSTG *iface)
2625 {
2626 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2627 LONG refcount = InterlockedDecrement(&psenum->refcount);
2628
2629 TRACE("%p, refcount %u.\n", iface, refcount);
2630
2631 if (!refcount)
2632 {
2633 heap_free(psenum->stats);
2634 heap_free(psenum);
2635 }
2636
2637 return refcount;
2638 }
2639
2640 static HRESULT WINAPI enum_stat_propset_stg_Next(IEnumSTATPROPSETSTG *iface, ULONG celt,
2641 STATPROPSETSTG *ret, ULONG *fetched)
2642 {
2643 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2644 ULONG count = 0;
2645
2646 TRACE("%p, %u, %p, %p.\n", iface, celt, ret, fetched);
2647
2648 if (psenum->current == ~0u)
2649 psenum->current = 0;
2650
2651 while (count < celt && psenum->current < psenum->count)
2652 ret[count++] = psenum->stats[psenum->current++];
2653
2654 if (fetched)
2655 *fetched = count;
2656
2657 return count < celt ? S_FALSE : S_OK;
2658 }
2659
2660 static HRESULT WINAPI enum_stat_propset_stg_Skip(IEnumSTATPROPSETSTG *iface, ULONG celt)
2661 {
2662 FIXME("%p, %u.\n", iface, celt);
2663
2664 return S_OK;
2665 }
2666
2667 static HRESULT WINAPI enum_stat_propset_stg_Reset(IEnumSTATPROPSETSTG *iface)
2668 {
2669 struct enum_stat_propset_stg *psenum = impl_from_IEnumSTATPROPSETSTG(iface);
2670
2671 TRACE("%p.\n", iface);
2672
2673 psenum->current = ~0u;
2674
2675 return S_OK;
2676 }
2677
2678 static HRESULT WINAPI enum_stat_propset_stg_Clone(IEnumSTATPROPSETSTG *iface, IEnumSTATPROPSETSTG **ppenum)
2679 {
2680 FIXME("%p, %p.\n", iface, ppenum);
2681
2682 return E_NOTIMPL;
2683 }
2684
2685 static const IEnumSTATPROPSETSTGVtbl enum_stat_propset_stg_vtbl =
2686 {
2687 enum_stat_propset_stg_QueryInterface,
2688 enum_stat_propset_stg_AddRef,
2689 enum_stat_propset_stg_Release,
2690 enum_stat_propset_stg_Next,
2691 enum_stat_propset_stg_Skip,
2692 enum_stat_propset_stg_Reset,
2693 enum_stat_propset_stg_Clone,
2694 };
2695
2696 static HRESULT create_enum_stat_propset_stg(StorageImpl *storage, IEnumSTATPROPSETSTG **ret)
2697 {
2698 IStorage *stg = &storage->base.IStorage_iface;
2699 IEnumSTATSTG *penum = NULL;
2700 STATSTG stat;
2701 ULONG count;
2702 HRESULT hr;
2703
2704 struct enum_stat_propset_stg *enum_obj;
2705
2706 enum_obj = heap_alloc_zero(sizeof(*enum_obj));
2707 if (!enum_obj)
2708 return E_OUTOFMEMORY;
2709
2710 enum_obj->IEnumSTATPROPSETSTG_iface.lpVtbl = &enum_stat_propset_stg_vtbl;
2711 enum_obj->refcount = 1;
2712
2713 /* add all the property set elements into a list */
2714 hr = IStorage_EnumElements(stg, 0, NULL, 0, &penum);
2715 if (FAILED(hr))
2716 goto done;
2717
2718 /* Allocate stats array and fill it. */
2719 while ((hr = IEnumSTATSTG_Next(penum, 1, &stat, &count)) == S_OK)
2720 {
2721 enum_obj->count++;
2722 CoTaskMemFree(stat.pwcsName);
2723 }
2724
2725 if (FAILED(hr))
2726 goto done;
2727
2728 enum_obj->stats = heap_alloc(enum_obj->count * sizeof(*enum_obj->stats));
2729 if (!enum_obj->stats)
2730 {
2731 hr = E_OUTOFMEMORY;
2732 goto done;
2733 }
2734 enum_obj->count = 0;
2735
2736 if (FAILED(hr = IEnumSTATSTG_Reset(penum)))
2737 goto done;
2738
2739 while (IEnumSTATSTG_Next(penum, 1, &stat, &count) == S_OK)
2740 {
2741 if (!stat.pwcsName)
2742 continue;
2743
2744 if (stat.pwcsName[0] == 5 && stat.type == STGTY_STREAM)
2745 {
2746 STATPROPSETSTG *ptr = &enum_obj->stats[enum_obj->count++];
2747
2748 PropStgNameToFmtId(stat.pwcsName, &ptr->fmtid);
2749
2750 TRACE("adding %s - %s.\n", debugstr_w(stat.pwcsName), debugstr_guid(&ptr->fmtid));
2751
2752 ptr->mtime = stat.mtime;
2753 ptr->atime = stat.atime;
2754 ptr->ctime = stat.ctime;
2755 ptr->grfFlags = stat.grfMode;
2756 ptr->clsid = stat.clsid;
2757 }
2758 CoTaskMemFree(stat.pwcsName);
2759 }
2760
2761 done:
2762
2763 if (penum)
2764 IEnumSTATSTG_Release(penum);
2765
2766 if (SUCCEEDED(hr))
2767 {
2768 *ret = &enum_obj->IEnumSTATPROPSETSTG_iface;
2769 }
2770 else
2771 {
2772 *ret = NULL;
2773 IEnumSTATPROPSETSTG_Release(&enum_obj->IEnumSTATPROPSETSTG_iface);
2774 }
2775
2776 return hr;
2777 }
2778
2779 /************************************************************************
2780 * IPropertySetStorage_fnQueryInterface (IUnknown)
2781 *
2782 * This method forwards to the common QueryInterface implementation
2783 */
2784 static HRESULT WINAPI IPropertySetStorage_fnQueryInterface(
2785 IPropertySetStorage *ppstg,
2786 REFIID riid,
2787 void** ppvObject)
2788 {
2789 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2790 return IStorage_QueryInterface( &This->base.IStorage_iface, riid, ppvObject );
2791 }
2792
2793 /************************************************************************
2794 * IPropertySetStorage_fnAddRef (IUnknown)
2795 *
2796 * This method forwards to the common AddRef implementation
2797 */
2798 static ULONG WINAPI IPropertySetStorage_fnAddRef(
2799 IPropertySetStorage *ppstg)
2800 {
2801 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2802 return IStorage_AddRef( &This->base.IStorage_iface );
2803 }
2804
2805 /************************************************************************
2806 * IPropertySetStorage_fnRelease (IUnknown)
2807 *
2808 * This method forwards to the common Release implementation
2809 */
2810 static ULONG WINAPI IPropertySetStorage_fnRelease(
2811 IPropertySetStorage *ppstg)
2812 {
2813 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2814 return IStorage_Release( &This->base.IStorage_iface );
2815 }
2816
2817 /************************************************************************
2818 * IPropertySetStorage_fnCreate (IPropertySetStorage)
2819 */
2820 static HRESULT WINAPI IPropertySetStorage_fnCreate(
2821 IPropertySetStorage *ppstg,
2822 REFFMTID rfmtid,
2823 const CLSID* pclsid,
2824 DWORD grfFlags,
2825 DWORD grfMode,
2826 IPropertyStorage** ppprstg)
2827 {
2828 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2829 WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
2830 IStream *stm = NULL;
2831 HRESULT r;
2832
2833 TRACE("%p %s %08x %08x %p\n", This, debugstr_guid(rfmtid), grfFlags,
2834 grfMode, ppprstg);
2835
2836 /* be picky */
2837 if (grfMode != (STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE))
2838 {
2839 r = STG_E_INVALIDFLAG;
2840 goto end;
2841 }
2842
2843 if (!rfmtid)
2844 {
2845 r = E_INVALIDARG;
2846 goto end;
2847 }
2848
2849 /* FIXME: if (grfFlags & PROPSETFLAG_NONSIMPLE), we need to create a
2850 * storage, not a stream. For now, disallow it.
2851 */
2852 if (grfFlags & PROPSETFLAG_NONSIMPLE)
2853 {
2854 FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
2855 r = STG_E_INVALIDFLAG;
2856 goto end;
2857 }
2858
2859 r = FmtIdToPropStgName(rfmtid, name);
2860 if (FAILED(r))
2861 goto end;
2862
2863 r = IStorage_CreateStream( &This->base.IStorage_iface, name, grfMode, 0, 0, &stm );
2864 if (FAILED(r))
2865 goto end;
2866
2867 r = PropertyStorage_ConstructEmpty(stm, rfmtid, grfFlags, grfMode, ppprstg);
2868
2869 IStream_Release( stm );
2870
2871 end:
2872 TRACE("returning 0x%08x\n", r);
2873 return r;
2874 }
2875
2876 /************************************************************************
2877 * IPropertySetStorage_fnOpen (IPropertySetStorage)
2878 */
2879 static HRESULT WINAPI IPropertySetStorage_fnOpen(
2880 IPropertySetStorage *ppstg,
2881 REFFMTID rfmtid,
2882 DWORD grfMode,
2883 IPropertyStorage** ppprstg)
2884 {
2885 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2886 IStream *stm = NULL;
2887 WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
2888 HRESULT r;
2889
2890 TRACE("%p %s %08x %p\n", This, debugstr_guid(rfmtid), grfMode, ppprstg);
2891
2892 /* be picky */
2893 if (grfMode != (STGM_READWRITE|STGM_SHARE_EXCLUSIVE) &&
2894 grfMode != (STGM_READ|STGM_SHARE_EXCLUSIVE))
2895 {
2896 r = STG_E_INVALIDFLAG;
2897 goto end;
2898 }
2899
2900 if (!rfmtid)
2901 {
2902 r = E_INVALIDARG;
2903 goto end;
2904 }
2905
2906 r = FmtIdToPropStgName(rfmtid, name);
2907 if (FAILED(r))
2908 goto end;
2909
2910 r = IStorage_OpenStream( &This->base.IStorage_iface, name, 0, grfMode, 0, &stm );
2911 if (FAILED(r))
2912 goto end;
2913
2914 r = PropertyStorage_ConstructFromStream(stm, rfmtid, grfMode, ppprstg);
2915
2916 IStream_Release( stm );
2917
2918 end:
2919 TRACE("returning 0x%08x\n", r);
2920 return r;
2921 }
2922
2923 /************************************************************************
2924 * IPropertySetStorage_fnDelete (IPropertySetStorage)
2925 */
2926 static HRESULT WINAPI IPropertySetStorage_fnDelete(
2927 IPropertySetStorage *ppstg,
2928 REFFMTID rfmtid)
2929 {
2930 StorageImpl *This = impl_from_IPropertySetStorage(ppstg);
2931 WCHAR name[CCH_MAX_PROPSTG_NAME + 1];
2932 HRESULT r;
2933
2934 TRACE("%p %s\n", This, debugstr_guid(rfmtid));
2935
2936 if (!rfmtid)
2937 return E_INVALIDARG;
2938
2939 r = FmtIdToPropStgName(rfmtid, name);
2940 if (FAILED(r))
2941 return r;
2942
2943 return IStorage_DestroyElement(&This->base.IStorage_iface, name);
2944 }
2945
2946 static HRESULT WINAPI IPropertySetStorage_fnEnum(IPropertySetStorage *iface, IEnumSTATPROPSETSTG **enum_obj)
2947 {
2948 StorageImpl *storage = impl_from_IPropertySetStorage(iface);
2949
2950 TRACE("%p, %p.\n", iface, enum_obj);
2951
2952 if (!enum_obj)
2953 return E_INVALIDARG;
2954
2955 return create_enum_stat_propset_stg(storage, enum_obj);
2956 }
2957
2958 /***********************************************************************
2959 * vtables
2960 */
2961 const IPropertySetStorageVtbl IPropertySetStorage_Vtbl =
2962 {
2963 IPropertySetStorage_fnQueryInterface,
2964 IPropertySetStorage_fnAddRef,
2965 IPropertySetStorage_fnRelease,
2966 IPropertySetStorage_fnCreate,
2967 IPropertySetStorage_fnOpen,
2968 IPropertySetStorage_fnDelete,
2969 IPropertySetStorage_fnEnum
2970 };
2971
2972 static const IPropertyStorageVtbl IPropertyStorage_Vtbl =
2973 {
2974 IPropertyStorage_fnQueryInterface,
2975 IPropertyStorage_fnAddRef,
2976 IPropertyStorage_fnRelease,
2977 IPropertyStorage_fnReadMultiple,
2978 IPropertyStorage_fnWriteMultiple,
2979 IPropertyStorage_fnDeleteMultiple,
2980 IPropertyStorage_fnReadPropertyNames,
2981 IPropertyStorage_fnWritePropertyNames,
2982 IPropertyStorage_fnDeletePropertyNames,
2983 IPropertyStorage_fnCommit,
2984 IPropertyStorage_fnRevert,
2985 IPropertyStorage_fnEnum,
2986 IPropertyStorage_fnSetTimes,
2987 IPropertyStorage_fnSetClass,
2988 IPropertyStorage_fnStat,
2989 };
2990
2991 /***********************************************************************
2992 * Format ID <-> name conversion
2993 */
2994 static const WCHAR szSummaryInfo[] = L"\5SummaryInformation";
2995 static const WCHAR szDocSummaryInfo[] = L"\5DocumentSummaryInformation";
2996
2997 #define BITS_PER_BYTE 8
2998 #define CHARMASK 0x1f
2999 #define BITS_IN_CHARMASK 5
3000 #define NUM_ALPHA_CHARS 26
3001
3002 /***********************************************************************
3003 * FmtIdToPropStgName [ole32.@]
3004 * Returns the storage name of the format ID rfmtid.
3005 * PARAMS
3006 * rfmtid [I] Format ID for which to return a storage name
3007 * str [O] Storage name associated with rfmtid.
3008 *
3009 * RETURNS
3010 * E_INVALIDARG if rfmtid or str i NULL, S_OK otherwise.
3011 *
3012 * NOTES
3013 * str must be at least CCH_MAX_PROPSTG_NAME characters in length.
3014 */
3015 HRESULT WINAPI FmtIdToPropStgName(const FMTID *rfmtid, LPOLESTR str)
3016 {
3017 static const char fmtMap[] = "abcdefghijklmnopqrstuvwxyz012345";
3018
3019 TRACE("%s, %p\n", debugstr_guid(rfmtid), str);
3020
3021 if (!rfmtid) return E_INVALIDARG;
3022 if (!str) return E_INVALIDARG;
3023
3024 if (IsEqualGUID(&FMTID_SummaryInformation, rfmtid))
3025 lstrcpyW(str, szSummaryInfo);
3026 else if (IsEqualGUID(&FMTID_DocSummaryInformation, rfmtid))
3027 lstrcpyW(str, szDocSummaryInfo);
3028 else if (IsEqualGUID(&FMTID_UserDefinedProperties, rfmtid))
3029 lstrcpyW(str, szDocSummaryInfo);
3030 else
3031 {
3032 const BYTE *fmtptr;
3033 WCHAR *pstr = str;
3034 ULONG bitsRemaining = BITS_PER_BYTE;
3035
3036 *pstr++ = 5;
3037 for (fmtptr = (const BYTE *)rfmtid; fmtptr < (const BYTE *)rfmtid + sizeof(FMTID); )
3038 {
3039 ULONG i = *fmtptr >> (BITS_PER_BYTE - bitsRemaining);
3040
3041 if (bitsRemaining >= BITS_IN_CHARMASK)
3042 {
3043 *pstr = (WCHAR)(fmtMap[i & CHARMASK]);
3044 if (bitsRemaining == BITS_PER_BYTE && *pstr >= 'a' &&
3045 *pstr <= 'z')
3046 *pstr += 'A' - 'a';
3047 pstr++;
3048 bitsRemaining -= BITS_IN_CHARMASK;
3049 if (bitsRemaining == 0)
3050 {
3051 fmtptr++;
3052 bitsRemaining = BITS_PER_BYTE;
3053 }
3054 }
3055 else
3056 {
3057 if (++fmtptr < (const BYTE *)rfmtid + sizeof(FMTID))
3058 i |= *fmtptr << bitsRemaining;
3059 *pstr++ = (WCHAR)(fmtMap[i & CHARMASK]);
3060 bitsRemaining += BITS_PER_BYTE - BITS_IN_CHARMASK;
3061 }
3062 }
3063 *pstr = 0;
3064 }
3065 TRACE("returning %s\n", debugstr_w(str));
3066 return S_OK;
3067 }
3068
3069 /***********************************************************************
3070 * PropStgNameToFmtId [ole32.@]
3071 * Returns the format ID corresponding to the given name.
3072 * PARAMS
3073 * str [I] Storage name to convert to a format ID.
3074 * rfmtid [O] Format ID corresponding to str.
3075 *
3076 * RETURNS
3077 * E_INVALIDARG if rfmtid or str is NULL or if str can't be converted to
3078 * a format ID, S_OK otherwise.
3079 */
3080 HRESULT WINAPI PropStgNameToFmtId(const LPOLESTR str, FMTID *rfmtid)
3081 {
3082 HRESULT hr = STG_E_INVALIDNAME;
3083
3084 TRACE("%s, %p\n", debugstr_w(str), rfmtid);
3085
3086 if (!rfmtid) return E_INVALIDARG;
3087 if (!str) return STG_E_INVALIDNAME;
3088
3089 if (!lstrcmpiW(str, szDocSummaryInfo))
3090 {
3091 *rfmtid = FMTID_DocSummaryInformation;
3092 hr = S_OK;
3093 }
3094 else if (!lstrcmpiW(str, szSummaryInfo))
3095 {
3096 *rfmtid = FMTID_SummaryInformation;
3097 hr = S_OK;
3098 }
3099 else
3100 {
3101 ULONG bits;
3102 BYTE *fmtptr = (BYTE *)rfmtid - 1;
3103 const WCHAR *pstr = str;
3104
3105 memset(rfmtid, 0, sizeof(*rfmtid));
3106 for (bits = 0; bits < sizeof(FMTID) * BITS_PER_BYTE;
3107 bits += BITS_IN_CHARMASK)
3108 {
3109 ULONG bitsUsed = bits % BITS_PER_BYTE, bitsStored;
3110 WCHAR wc;
3111
3112 if (bitsUsed == 0)
3113 fmtptr++;
3114 wc = *++pstr - 'A';
3115 if (wc > NUM_ALPHA_CHARS)
3116 {
3117 wc += 'A' - 'a';
3118 if (wc > NUM_ALPHA_CHARS)
3119 {
3120 wc += 'a' - '0' + NUM_ALPHA_CHARS;
3121 if (wc > CHARMASK)
3122 {
3123 WARN("invalid character (%d)\n", *pstr);
3124 goto end;
3125 }
3126 }
3127 }
3128 *fmtptr |= wc << bitsUsed;
3129 bitsStored = min(BITS_PER_BYTE - bitsUsed, BITS_IN_CHARMASK);
3130 if (bitsStored < BITS_IN_CHARMASK)
3131 {
3132 wc >>= BITS_PER_BYTE - bitsUsed;
3133 if (bits + bitsStored == sizeof(FMTID) * BITS_PER_BYTE)
3134 {
3135 if (wc != 0)
3136 {
3137 WARN("extra bits\n");
3138 goto end;
3139 }
3140 break;
3141 }
3142 fmtptr++;
3143 *fmtptr |= (BYTE)wc;
3144 }
3145 }
3146 hr = S_OK;
3147 }
3148 end:
3149 return hr;
3150 }
3151
3152 #ifdef __i386__ /* thiscall functions are i386-specific */
3153
3154 #define DEFINE_STDCALL_WRAPPER(num,func,args) \
3155 __ASM_STDCALL_FUNC(func, args, \
3156 "popl %eax\n\t" \
3157 "popl %ecx\n\t" \
3158 "pushl %eax\n\t" \
3159 "movl (%ecx), %eax\n\t" \
3160 "jmp *(4*(" #num "))(%eax)" )
3161
3162 DEFINE_STDCALL_WRAPPER(0,Allocate_PMemoryAllocator,8)
3163 extern void* WINAPI Allocate_PMemoryAllocator(void *this, ULONG cbSize);
3164
3165 #else
3166
3167 static void* WINAPI Allocate_PMemoryAllocator(void *this, ULONG cbSize)
3168 {
3169 void* (WINAPI *fn)(void*,ULONG) = **(void***)this;
3170 return fn(this, cbSize);
3171 }
3172
3173 #endif
3174
3175 BOOLEAN WINAPI StgConvertPropertyToVariant(const SERIALIZEDPROPERTYVALUE* prop,
3176 USHORT CodePage, PROPVARIANT* pvar, void* pma)
3177 {
3178 struct read_buffer read_buffer;
3179 HRESULT hr;
3180
3181 read_buffer.data = (BYTE *)prop;
3182 read_buffer.size = ~(size_t)0;
3183 hr = PropertyStorage_ReadProperty(pvar, &read_buffer, 0, CodePage, Allocate_PMemoryAllocator, pma);
3184
3185 if (FAILED(hr))
3186 {
3187 FIXME("should raise C++ exception on failure\n");
3188 PropVariantInit(pvar);
3189 }
3190
3191 return FALSE;
3192 }
3193
3194 SERIALIZEDPROPERTYVALUE* WINAPI StgConvertVariantToProperty(const PROPVARIANT *pvar,
3195 USHORT CodePage, SERIALIZEDPROPERTYVALUE *pprop, ULONG *pcb, PROPID pid,
3196 BOOLEAN fReserved, ULONG *pcIndirect)
3197 {
3198 FIXME("%p,%d,%p,%p,%d,%d,%p\n", pvar, CodePage, pprop, pcb, pid, fReserved, pcIndirect);
3199
3200 return NULL;
3201 }
3202
3203 HRESULT WINAPI StgCreatePropStg(IUnknown *unk, REFFMTID fmt, const CLSID *clsid,
3204 DWORD flags, DWORD reserved, IPropertyStorage **prop_stg)
3205 {
3206 IStorage *stg;
3207 IStream *stm;
3208 HRESULT r;
3209
3210 TRACE("%p %s %s %08x %d %p\n", unk, debugstr_guid(fmt), debugstr_guid(clsid), flags, reserved, prop_stg);
3211
3212 if (!fmt || reserved)
3213 {
3214 r = E_INVALIDARG;
3215 goto end;
3216 }
3217
3218 if (flags & PROPSETFLAG_NONSIMPLE)
3219 {
3220 r = IUnknown_QueryInterface(unk, &IID_IStorage, (void **)&stg);
3221 if (FAILED(r))
3222 goto end;
3223
3224 /* FIXME: if (flags & PROPSETFLAG_NONSIMPLE), we need to create a
3225 * storage, not a stream. For now, disallow it.
3226 */
3227 FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
3228 IStorage_Release(stg);
3229 r = STG_E_INVALIDFLAG;
3230 }
3231 else
3232 {
3233 r = IUnknown_QueryInterface(unk, &IID_IStream, (void **)&stm);
3234 if (FAILED(r))
3235 goto end;
3236
3237 r = PropertyStorage_ConstructEmpty(stm, fmt, flags,
3238 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, prop_stg);
3239
3240 IStream_Release( stm );
3241 }
3242
3243 end:
3244 TRACE("returning 0x%08x\n", r);
3245 return r;
3246 }
3247
3248 HRESULT WINAPI StgOpenPropStg(IUnknown *unk, REFFMTID fmt, DWORD flags,
3249 DWORD reserved, IPropertyStorage **prop_stg)
3250 {
3251 IStorage *stg;
3252 IStream *stm;
3253 HRESULT r;
3254
3255 TRACE("%p %s %08x %d %p\n", unk, debugstr_guid(fmt), flags, reserved, prop_stg);
3256
3257 if (!fmt || reserved)
3258 {
3259 r = E_INVALIDARG;
3260 goto end;
3261 }
3262
3263 if (flags & PROPSETFLAG_NONSIMPLE)
3264 {
3265 r = IUnknown_QueryInterface(unk, &IID_IStorage, (void **)&stg);
3266 if (FAILED(r))
3267 goto end;
3268
3269 /* FIXME: if (flags & PROPSETFLAG_NONSIMPLE), we need to open a
3270 * storage, not a stream. For now, disallow it.
3271 */
3272 FIXME("PROPSETFLAG_NONSIMPLE not supported\n");
3273 IStorage_Release(stg);
3274 r = STG_E_INVALIDFLAG;
3275 }
3276 else
3277 {
3278 r = IUnknown_QueryInterface(unk, &IID_IStream, (void **)&stm);
3279 if (FAILED(r))
3280 goto end;
3281
3282 r = PropertyStorage_ConstructFromStream(stm, fmt,
3283 STGM_READWRITE|STGM_SHARE_EXCLUSIVE, prop_stg);
3284
3285 IStream_Release( stm );
3286 }
3287
3288 end:
3289 TRACE("returning 0x%08x\n", r);
3290 return r;
3291 }
Windows API implementation