msi: Add tests for situations involving missing cabinets.
[wine] / dlls / msi / suminfo.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2002, 2005 Mike McCormack for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winreg.h"
29 #include "winnls.h"
30 #include "shlwapi.h"
31 #include "wine/debug.h"
32 #include "msi.h"
33 #include "msiquery.h"
34 #include "msidefs.h"
35 #include "msipriv.h"
36 #include "objidl.h"
37 #include "msiserver.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(msi);
40
41 #include "pshpack1.h"
42
43 typedef struct { 
44     WORD wByteOrder;
45     WORD wFormat;
46     DWORD dwOSVer;
47     CLSID clsID;
48     DWORD reserved;
49 } PROPERTYSETHEADER;
50
51 typedef struct { 
52     FMTID fmtid;
53     DWORD dwOffset;
54 } FORMATIDOFFSET;
55
56 typedef struct { 
57     DWORD cbSection;
58     DWORD cProperties;
59 } PROPERTYSECTIONHEADER; 
60  
61 typedef struct { 
62     DWORD propid;
63     DWORD dwOffset;
64 } PROPERTYIDOFFSET; 
65
66 typedef struct {
67     DWORD type;
68     union {
69         INT i4;
70         SHORT i2;
71         FILETIME ft;
72         struct {
73             DWORD len;
74             BYTE str[1];
75         } str;
76     } u;
77 } PROPERTY_DATA;
78  
79 #include "poppack.h"
80
81 #define SECT_HDR_SIZE (sizeof(PROPERTYSECTIONHEADER))
82
83 static const WCHAR szSumInfo[] = { 5 ,'S','u','m','m','a','r','y',
84                        'I','n','f','o','r','m','a','t','i','o','n',0 };
85
86 static void free_prop( PROPVARIANT *prop )
87 {
88     if (prop->vt == VT_LPSTR )
89         msi_free( prop->u.pszVal );
90     prop->vt = VT_EMPTY;
91 }
92
93 static void MSI_CloseSummaryInfo( MSIOBJECTHDR *arg )
94 {
95     MSISUMMARYINFO *si = (MSISUMMARYINFO *) arg;
96     DWORD i;
97
98     for( i = 0; i < MSI_MAX_PROPS; i++ )
99         free_prop( &si->property[i] );
100     IStorage_Release( si->storage );
101 }
102
103 static UINT get_type( UINT uiProperty )
104 {
105     switch( uiProperty )
106     {
107     case PID_CODEPAGE:
108          return VT_I2;
109
110     case PID_SUBJECT:
111     case PID_AUTHOR:
112     case PID_KEYWORDS:
113     case PID_COMMENTS:
114     case PID_TEMPLATE:
115     case PID_LASTAUTHOR:
116     case PID_REVNUMBER:
117     case PID_APPNAME:
118     case PID_TITLE:
119          return VT_LPSTR;
120
121     case PID_LASTPRINTED:
122     case PID_CREATE_DTM:
123     case PID_LASTSAVE_DTM:
124          return VT_FILETIME;
125
126     case PID_WORDCOUNT:
127     case PID_CHARCOUNT:
128     case PID_SECURITY:
129     case PID_PAGECOUNT:
130          return VT_I4;
131     }
132     return VT_EMPTY;
133 }
134
135 static UINT get_property_count( const PROPVARIANT *property )
136 {
137     UINT i, n = 0;
138
139     if( !property )
140         return n;
141     for( i = 0; i < MSI_MAX_PROPS; i++ )
142         if( property[i].vt != VT_EMPTY )
143             n++;
144     return n;
145 }
146
147 /* FIXME: doesn't deal with endian conversion */
148 static void read_properties_from_data( PROPVARIANT *prop, LPBYTE data, DWORD sz )
149 {
150     UINT type;
151     DWORD i;
152     int size;
153     PROPERTY_DATA *propdata;
154     PROPVARIANT *property;
155     PROPERTYIDOFFSET *idofs;
156     PROPERTYSECTIONHEADER *section_hdr;
157
158     section_hdr = (PROPERTYSECTIONHEADER*) &data[0];
159     idofs = (PROPERTYIDOFFSET*) &data[SECT_HDR_SIZE];
160
161     /* now set all the properties */
162     for( i = 0; i < section_hdr->cProperties; i++ )
163     {
164         type = get_type( idofs[i].propid );
165         if( type == VT_EMPTY )
166         {
167             ERR("propid %d has unknown type\n", idofs[i].propid);
168             break;
169         }
170
171         propdata = (PROPERTY_DATA*) &data[ idofs[i].dwOffset ];
172
173         /* check the type is the same as we expect */
174         if( type != propdata->type )
175         {
176             ERR("wrong type %d != %d\n", type, propdata->type);
177             break;
178         }
179
180         /* check we don't run off the end of the data */
181         size = sz - idofs[i].dwOffset - sizeof(DWORD);
182         if( sizeof(DWORD) > size ||
183             ( type == VT_FILETIME && sizeof(FILETIME) > size ) ||
184             ( type == VT_LPSTR && (propdata->u.str.len + sizeof(DWORD)) > size ) )
185         {
186             ERR("not enough data\n");
187             break;
188         }
189
190         if( idofs[i].propid >= MSI_MAX_PROPS )
191         {
192             ERR("Unknown property ID %d\n", idofs[i].propid );
193             break;
194         }
195
196         property = &prop[ idofs[i].propid ];
197         property->vt = type;
198
199         if( type == VT_LPSTR )
200         {
201             LPSTR str = msi_alloc( propdata->u.str.len );
202             memcpy( str, propdata->u.str.str, propdata->u.str.len );
203             str[ propdata->u.str.len - 1 ] = 0;
204             property->u.pszVal = str;
205         }
206         else if( type == VT_FILETIME )
207             property->u.filetime = propdata->u.ft;
208         else if( type == VT_I2 )
209             property->u.iVal = propdata->u.i2;
210         else if( type == VT_I4 )
211             property->u.lVal = propdata->u.i4;
212     }
213 }
214
215 static UINT load_summary_info( MSISUMMARYINFO *si, IStream *stm )
216 {
217     UINT ret = ERROR_FUNCTION_FAILED;
218     PROPERTYSETHEADER set_hdr;
219     FORMATIDOFFSET format_hdr;
220     PROPERTYSECTIONHEADER section_hdr;
221     LPBYTE data = NULL;
222     LARGE_INTEGER ofs;
223     ULONG count, sz;
224     HRESULT r;
225
226     TRACE("%p %p\n", si, stm);
227
228     /* read the header */
229     sz = sizeof set_hdr;
230     r = IStream_Read( stm, &set_hdr, sz, &count );
231     if( FAILED(r) || count != sz )
232         return ret;
233
234     if( set_hdr.wByteOrder != 0xfffe )
235     {
236         ERR("property set not big-endian %04X\n", set_hdr.wByteOrder);
237         return ret;
238     }
239
240     sz = sizeof format_hdr;
241     r = IStream_Read( stm, &format_hdr, sz, &count );
242     if( FAILED(r) || count != sz )
243         return ret;
244
245     /* check the format id is correct */
246     if( !IsEqualGUID( &FMTID_SummaryInformation, &format_hdr.fmtid ) )
247         return ret;
248
249     /* seek to the location of the section */
250     ofs.QuadPart = format_hdr.dwOffset;
251     r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, NULL );
252     if( FAILED(r) )
253         return ret;
254
255     /* read the section itself */
256     sz = SECT_HDR_SIZE;
257     r = IStream_Read( stm, &section_hdr, sz, &count );
258     if( FAILED(r) || count != sz )
259         return ret;
260
261     if( section_hdr.cProperties > MSI_MAX_PROPS )
262     {
263         ERR("too many properties %d\n", section_hdr.cProperties);
264         return ret;
265     }
266
267     data = msi_alloc( section_hdr.cbSection);
268     if( !data )
269         return ret;
270
271     memcpy( data, &section_hdr, SECT_HDR_SIZE );
272
273     /* read all the data in one go */
274     sz = section_hdr.cbSection - SECT_HDR_SIZE;
275     r = IStream_Read( stm, &data[ SECT_HDR_SIZE ], sz, &count );
276     if( SUCCEEDED(r) && count == sz )
277         read_properties_from_data( si->property, data, sz + SECT_HDR_SIZE );
278     else
279         ERR("failed to read properties %d %d\n", count, sz);
280
281     msi_free( data );
282     return ret;
283 }
284
285 static DWORD write_dword( LPBYTE data, DWORD ofs, DWORD val )
286 {
287     if( data )
288     {
289         data[ofs++] = val&0xff;
290         data[ofs++] = (val>>8)&0xff;
291         data[ofs++] = (val>>16)&0xff;
292         data[ofs++] = (val>>24)&0xff;
293     }
294     return 4;
295 }
296
297 static DWORD write_filetime( LPBYTE data, DWORD ofs, const FILETIME *ft )
298 {
299     write_dword( data, ofs, ft->dwLowDateTime );
300     write_dword( data, ofs + 4, ft->dwHighDateTime );
301     return 8;
302 }
303
304 static DWORD write_string( LPBYTE data, DWORD ofs, LPCSTR str )
305 {
306     DWORD len = lstrlenA( str ) + 1;
307     write_dword( data, ofs, len );
308     if( data )
309         memcpy( &data[ofs + 4], str, len );
310     return (7 + len) & ~3;
311 }
312
313 static UINT write_property_to_data( const PROPVARIANT *prop, LPBYTE data )
314 {
315     DWORD sz = 0;
316
317     if( prop->vt == VT_EMPTY )
318         return sz;
319
320     /* add the type */
321     sz += write_dword( data, sz, prop->vt );
322     switch( prop->vt )
323     {
324     case VT_I2:
325         sz += write_dword( data, sz, prop->u.iVal );
326         break;
327     case VT_I4:
328         sz += write_dword( data, sz, prop->u.lVal );
329         break;
330     case VT_FILETIME:
331         sz += write_filetime( data, sz, &prop->u.filetime );
332         break;
333     case VT_LPSTR:
334         sz += write_string( data, sz, prop->u.pszVal );
335         break;
336     }
337     return sz;
338 }
339
340 static UINT save_summary_info( const MSISUMMARYINFO * si, IStream *stm )
341 {
342     UINT ret = ERROR_FUNCTION_FAILED;
343     PROPERTYSETHEADER set_hdr;
344     FORMATIDOFFSET format_hdr;
345     PROPERTYSECTIONHEADER section_hdr;
346     PROPERTYIDOFFSET idofs[MSI_MAX_PROPS];
347     LPBYTE data = NULL;
348     ULONG count, sz;
349     HRESULT r;
350     int i, n;
351
352     /* write the header */
353     sz = sizeof set_hdr;
354     memset( &set_hdr, 0, sz );
355     set_hdr.wByteOrder = 0xfffe;
356     set_hdr.wFormat = 0;
357     set_hdr.dwOSVer = 0x00020005; /* build 5, platform id 2 */
358     /* set_hdr.clsID is {00000000-0000-0000-0000-000000000000} */
359     set_hdr.reserved = 1;
360     r = IStream_Write( stm, &set_hdr, sz, &count );
361     if( FAILED(r) || count != sz )
362         return ret;
363
364     /* write the format header */
365     sz = sizeof format_hdr;
366     memcpy( &format_hdr.fmtid, &FMTID_SummaryInformation, sizeof (FMTID) );
367     format_hdr.dwOffset = sizeof format_hdr + sizeof set_hdr;
368     r = IStream_Write( stm, &format_hdr, sz, &count );
369     if( FAILED(r) || count != sz )
370         return ret;
371
372     /* add up how much space the data will take and calculate the offsets */
373     section_hdr.cbSection = sizeof section_hdr;
374     section_hdr.cbSection += (get_property_count( si->property ) * sizeof idofs[0]);
375     section_hdr.cProperties = 0;
376     n = 0;
377     for( i = 0; i < MSI_MAX_PROPS; i++ )
378     {
379         sz = write_property_to_data( &si->property[i], NULL );
380         if( !sz )
381             continue;
382         idofs[ section_hdr.cProperties ].propid = i;
383         idofs[ section_hdr.cProperties ].dwOffset = section_hdr.cbSection;
384         section_hdr.cProperties++;
385         section_hdr.cbSection += sz;
386     }
387
388     data = msi_alloc_zero( section_hdr.cbSection );
389
390     sz = 0;
391     memcpy( &data[sz], &section_hdr, sizeof section_hdr );
392     sz += sizeof section_hdr;
393
394     memcpy( &data[sz], idofs, section_hdr.cProperties * sizeof idofs[0] );
395     sz += section_hdr.cProperties * sizeof idofs[0];
396
397     /* write out the data */
398     for( i = 0; i < MSI_MAX_PROPS; i++ )
399         sz += write_property_to_data( &si->property[i], &data[sz] );
400
401     r = IStream_Write( stm, data, sz, &count );
402     msi_free( data );
403     if( FAILED(r) || count != sz )
404         return ret;
405
406     return ERROR_SUCCESS;
407 }
408
409 MSISUMMARYINFO *MSI_GetSummaryInformationW( IStorage *stg, UINT uiUpdateCount )
410 {
411     IStream *stm = NULL;
412     MSISUMMARYINFO *si;
413     DWORD grfMode;
414     HRESULT r;
415
416     TRACE("%p %d\n", stg, uiUpdateCount );
417
418     si = alloc_msiobject( MSIHANDLETYPE_SUMMARYINFO, 
419                   sizeof (MSISUMMARYINFO), MSI_CloseSummaryInfo );
420     if( !si )
421         return si;
422
423     memset( &si->property, 0, sizeof si->property );
424     si->update_count = uiUpdateCount;
425     IStorage_AddRef( stg );
426     si->storage = stg;
427
428     /* read the stream... if we fail, we'll start with an empty property set */
429     grfMode = STGM_READ | STGM_SHARE_EXCLUSIVE;
430     r = IStorage_OpenStream( si->storage, szSumInfo, 0, grfMode, 0, &stm );
431     if( SUCCEEDED(r) )
432     {
433         load_summary_info( si, stm );
434         IStream_Release( stm );
435     }
436
437     return si;
438 }
439
440 UINT WINAPI MsiGetSummaryInformationW( MSIHANDLE hDatabase, 
441               LPCWSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle )
442 {
443     MSISUMMARYINFO *si;
444     MSIDATABASE *db;
445     UINT ret = ERROR_FUNCTION_FAILED;
446
447     TRACE("%ld %s %d %p\n", hDatabase, debugstr_w(szDatabase),
448            uiUpdateCount, pHandle);
449
450     if( !pHandle )
451         return ERROR_INVALID_PARAMETER;
452
453     if( szDatabase )
454     {
455         ret = MSI_OpenDatabaseW( szDatabase, NULL, &db );
456         if( ret != ERROR_SUCCESS )
457             return ret;
458     }
459     else
460     {
461         db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
462         if( !db )
463         {
464             HRESULT hr;
465             IWineMsiRemoteDatabase *remote_database;
466
467             remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hDatabase );
468             if ( !remote_database )
469                 return ERROR_INVALID_HANDLE;
470
471             hr = IWineMsiRemoteDatabase_GetSummaryInformation( remote_database,
472                                                                uiUpdateCount, pHandle );
473             IWineMsiRemoteDatabase_Release( remote_database );
474
475             if (FAILED(hr))
476             {
477                 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
478                     return HRESULT_CODE(hr);
479
480                 return ERROR_FUNCTION_FAILED;
481             }
482
483             return ERROR_SUCCESS;
484         }
485     }
486
487     si = MSI_GetSummaryInformationW( db->storage, uiUpdateCount );
488     if (si)
489     {
490         *pHandle = alloc_msihandle( &si->hdr );
491         if( *pHandle )
492             ret = ERROR_SUCCESS;
493         else
494             ret = ERROR_NOT_ENOUGH_MEMORY;
495         msiobj_release( &si->hdr );
496     }
497
498     if( db )
499         msiobj_release( &db->hdr );
500
501     return ret;
502 }
503
504 UINT WINAPI MsiGetSummaryInformationA(MSIHANDLE hDatabase, 
505               LPCSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle)
506 {
507     LPWSTR szwDatabase = NULL;
508     UINT ret;
509
510     TRACE("%ld %s %d %p\n", hDatabase, debugstr_a(szDatabase), 
511           uiUpdateCount, pHandle);
512
513     if( szDatabase )
514     {
515         szwDatabase = strdupAtoW( szDatabase );
516         if( !szwDatabase )
517             return ERROR_FUNCTION_FAILED;
518     }
519
520     ret = MsiGetSummaryInformationW(hDatabase, szwDatabase, uiUpdateCount, pHandle);
521
522     msi_free( szwDatabase );
523
524     return ret;
525 }
526
527 UINT WINAPI MsiSummaryInfoGetPropertyCount(MSIHANDLE hSummaryInfo, PUINT pCount)
528 {
529     MSISUMMARYINFO *si;
530
531     TRACE("%ld %p\n", hSummaryInfo, pCount);
532
533     si = msihandle2msiinfo( hSummaryInfo, MSIHANDLETYPE_SUMMARYINFO );
534     if( !si )
535         return ERROR_INVALID_HANDLE;
536
537     if( pCount )
538         *pCount = get_property_count( si->property );
539     msiobj_release( &si->hdr );
540
541     return ERROR_SUCCESS;
542 }
543
544 static UINT get_prop( MSIHANDLE handle, UINT uiProperty, UINT *puiDataType,
545           INT *piValue, FILETIME *pftValue, awstring *str, DWORD *pcchValueBuf)
546 {
547     MSISUMMARYINFO *si;
548     PROPVARIANT *prop;
549     UINT ret = ERROR_SUCCESS;
550
551     TRACE("%ld %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
552           piValue, pftValue, str, pcchValueBuf);
553
554     if ( uiProperty >= MSI_MAX_PROPS )
555     {
556         if (puiDataType) *puiDataType = VT_EMPTY;
557         return ERROR_UNKNOWN_PROPERTY;
558     }
559
560     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
561     if( !si )
562         return ERROR_INVALID_HANDLE;
563
564     prop = &si->property[uiProperty];
565
566     if( puiDataType )
567         *puiDataType = prop->vt;
568
569     switch( prop->vt )
570     {
571     case VT_I2:
572         if( piValue )
573             *piValue = prop->u.iVal;
574         break;
575     case VT_I4:
576         if( piValue )
577             *piValue = prop->u.lVal;
578         break;
579     case VT_LPSTR:
580         if( pcchValueBuf )
581         {
582             DWORD len = 0;
583
584             if( str->unicode )
585             {
586                 len = MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1,
587                                            str->str.w, *pcchValueBuf );
588                 len--;
589             }
590             else
591             {
592                 len = lstrlenA( prop->u.pszVal );
593                 if( str->str.a )
594                     lstrcpynA(str->str.a, prop->u.pszVal, *pcchValueBuf );
595             }
596             if (len >= *pcchValueBuf)
597                 ret = ERROR_MORE_DATA;
598             *pcchValueBuf = len;
599         }
600         break;
601     case VT_FILETIME:
602         if( pftValue )
603             memcpy(pftValue, &prop->u.filetime, sizeof (FILETIME) );
604         break;
605     case VT_EMPTY:
606         break;
607     default:
608         FIXME("Unknown property variant type\n");
609         break;
610     }
611     msiobj_release( &si->hdr );
612     return ret;
613 }
614
615 LPWSTR msi_suminfo_dup_string( MSISUMMARYINFO *si, UINT uiProperty )
616 {
617     PROPVARIANT *prop;
618
619     if ( uiProperty >= MSI_MAX_PROPS )
620         return NULL;
621     prop = &si->property[uiProperty];
622     if( prop->vt != VT_LPSTR )
623         return NULL;
624     return strdupAtoW( prop->u.pszVal );
625 }
626
627 LPWSTR msi_get_suminfo_product( IStorage *stg )
628 {
629     MSISUMMARYINFO *si;
630     LPWSTR prod;
631
632     si = MSI_GetSummaryInformationW( stg, 0 );
633     if (!si)
634     {
635         ERR("no summary information!\n");
636         return NULL;
637     }
638     prod = msi_suminfo_dup_string( si, PID_REVNUMBER );
639     msiobj_release( &si->hdr );
640     return prod;
641 }
642
643 UINT WINAPI MsiSummaryInfoGetPropertyA(
644       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
645       FILETIME *pftValue, LPSTR szValueBuf, LPDWORD pcchValueBuf)
646 {
647     awstring str;
648
649     TRACE("%ld %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
650           piValue, pftValue, szValueBuf, pcchValueBuf );
651
652     str.unicode = FALSE;
653     str.str.a = szValueBuf;
654
655     return get_prop( handle, uiProperty, puiDataType, piValue,
656                      pftValue, &str, pcchValueBuf );
657 }
658
659 UINT WINAPI MsiSummaryInfoGetPropertyW(
660       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
661       FILETIME *pftValue, LPWSTR szValueBuf, LPDWORD pcchValueBuf)
662 {
663     awstring str;
664
665     TRACE("%ld %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
666           piValue, pftValue, szValueBuf, pcchValueBuf );
667
668     str.unicode = TRUE;
669     str.str.w = szValueBuf;
670
671     return get_prop( handle, uiProperty, puiDataType, piValue,
672                      pftValue, &str, pcchValueBuf );
673 }
674
675 static UINT set_prop( MSIHANDLE handle, UINT uiProperty, UINT uiDataType,
676                INT iValue, FILETIME* pftValue, awcstring *str )
677 {
678     MSISUMMARYINFO *si;
679     PROPVARIANT *prop;
680     UINT type, len, ret = ERROR_SUCCESS;
681
682     TRACE("%ld %u %u %i %p %p\n", handle, uiProperty, uiDataType,
683           iValue, pftValue, str );
684
685     type = get_type( uiProperty );
686     if( type == VT_EMPTY || type != uiDataType )
687         return ERROR_DATATYPE_MISMATCH;
688
689     if( uiDataType == VT_LPSTR && !str->str.w )
690         return ERROR_INVALID_PARAMETER;
691
692     if( uiDataType == VT_FILETIME && !pftValue )
693         return ERROR_INVALID_PARAMETER;
694
695     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
696     if( !si )
697         return ERROR_INVALID_HANDLE;
698
699     prop = &si->property[uiProperty];
700
701     if( prop->vt == VT_EMPTY )
702     {
703         if( !si->update_count )
704         {
705             ret = ERROR_FUNCTION_FAILED;
706             goto end;
707         }
708         si->update_count--;
709     }
710     else if( prop->vt != type )
711         goto end;
712
713     free_prop( prop );
714     prop->vt = type;
715     switch( type )
716     {
717     case VT_I4:
718         prop->u.lVal = iValue;
719         break;
720     case VT_I2:
721         prop->u.iVal = iValue;
722         break;
723     case VT_FILETIME:
724         memcpy( &prop->u.filetime, pftValue, sizeof prop->u.filetime );
725         break;
726     case VT_LPSTR:
727         if( str->unicode )
728         {
729             len = WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
730                                        NULL, 0, NULL, NULL );
731             prop->u.pszVal = msi_alloc( len );
732             WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
733                                  prop->u.pszVal, len, NULL, NULL );
734         }
735         else
736         {
737             len = lstrlenA( str->str.a ) + 1;
738             prop->u.pszVal = msi_alloc( len );
739             lstrcpyA( prop->u.pszVal, str->str.a );
740         }
741         break;
742     }
743
744 end:
745     msiobj_release( &si->hdr );
746     return ret;
747 }
748
749 UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty,
750                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCWSTR szValue )
751 {
752     awcstring str;
753
754     TRACE("%ld %u %u %i %p %s\n", handle, uiProperty, uiDataType,
755           iValue, pftValue, debugstr_w(szValue) );
756
757     str.unicode = TRUE;
758     str.str.w = szValue;
759     return set_prop( handle, uiProperty, uiDataType, iValue, pftValue, &str );
760 }
761
762 UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty,
763                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCSTR szValue )
764 {
765     awcstring str;
766
767     TRACE("%ld %u %u %i %p %s\n", handle, uiProperty, uiDataType,
768           iValue, pftValue, debugstr_a(szValue) );
769
770     str.unicode = FALSE;
771     str.str.a = szValue;
772     return set_prop( handle, uiProperty, uiDataType, iValue, pftValue, &str );
773 }
774
775 UINT WINAPI MsiSummaryInfoPersist( MSIHANDLE handle )
776 {
777     IStream *stm = NULL;
778     MSISUMMARYINFO *si;
779     DWORD grfMode;
780     HRESULT r;
781     UINT ret = ERROR_FUNCTION_FAILED;
782
783     TRACE("%ld\n", handle );
784
785     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
786     if( !si )
787         return ERROR_INVALID_HANDLE;
788
789     grfMode = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
790     r = IStorage_CreateStream( si->storage, szSumInfo, grfMode, 0, 0, &stm );
791     if( SUCCEEDED(r) )
792     {
793         ret = save_summary_info( si, stm );
794         IStream_Release( stm );
795     }
796     msiobj_release( &si->hdr );
797
798     return ret;
799 }