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