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