msi/tests: Return an error code from helper_createpackage and package_from_db.
[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 "wine/unicode.h"
33 #include "msi.h"
34 #include "msiquery.h"
35 #include "msidefs.h"
36 #include "msipriv.h"
37 #include "objidl.h"
38 #include "propvarutil.h"
39 #include "msiserver.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
42
43 #include "pshpack1.h"
44
45 typedef struct { 
46     WORD wByteOrder;
47     WORD wFormat;
48     DWORD dwOSVer;
49     CLSID clsID;
50     DWORD reserved;
51 } PROPERTYSETHEADER;
52
53 typedef struct { 
54     FMTID fmtid;
55     DWORD dwOffset;
56 } FORMATIDOFFSET;
57
58 typedef struct { 
59     DWORD cbSection;
60     DWORD cProperties;
61 } PROPERTYSECTIONHEADER; 
62  
63 typedef struct { 
64     DWORD propid;
65     DWORD dwOffset;
66 } PROPERTYIDOFFSET; 
67
68 typedef struct {
69     DWORD type;
70     union {
71         INT i4;
72         SHORT i2;
73         FILETIME ft;
74         struct {
75             DWORD len;
76             BYTE str[1];
77         } str;
78     } u;
79 } PROPERTY_DATA;
80  
81 #include "poppack.h"
82
83 static HRESULT (WINAPI *pPropVariantChangeType)
84     (PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
85      PROPVAR_CHANGE_FLAGS flags, VARTYPE vt);
86
87 #define SECT_HDR_SIZE (sizeof(PROPERTYSECTIONHEADER))
88
89 static void free_prop( PROPVARIANT *prop )
90 {
91     if (prop->vt == VT_LPSTR )
92         msi_free( prop->u.pszVal );
93     prop->vt = VT_EMPTY;
94 }
95
96 static void MSI_CloseSummaryInfo( MSIOBJECTHDR *arg )
97 {
98     MSISUMMARYINFO *si = (MSISUMMARYINFO *) arg;
99     DWORD i;
100
101     for( i = 0; i < MSI_MAX_PROPS; i++ )
102         free_prop( &si->property[i] );
103     IStorage_Release( si->storage );
104 }
105
106 static UINT get_type( UINT uiProperty )
107 {
108     switch( uiProperty )
109     {
110     case PID_CODEPAGE:
111          return VT_I2;
112
113     case PID_SUBJECT:
114     case PID_AUTHOR:
115     case PID_KEYWORDS:
116     case PID_COMMENTS:
117     case PID_TEMPLATE:
118     case PID_LASTAUTHOR:
119     case PID_REVNUMBER:
120     case PID_APPNAME:
121     case PID_TITLE:
122          return VT_LPSTR;
123
124     case PID_LASTPRINTED:
125     case PID_CREATE_DTM:
126     case PID_LASTSAVE_DTM:
127          return VT_FILETIME;
128
129     case PID_WORDCOUNT:
130     case PID_CHARCOUNT:
131     case PID_SECURITY:
132     case PID_PAGECOUNT:
133          return VT_I4;
134     }
135     return VT_EMPTY;
136 }
137
138 static UINT get_property_count( const PROPVARIANT *property )
139 {
140     UINT i, n = 0;
141
142     if( !property )
143         return n;
144     for( i = 0; i < MSI_MAX_PROPS; i++ )
145         if( property[i].vt != VT_EMPTY )
146             n++;
147     return n;
148 }
149
150 static UINT propvar_changetype(PROPVARIANT *changed, PROPVARIANT *property, VARTYPE vt)
151 {
152     HRESULT hr;
153     HMODULE propsys = LoadLibraryA("propsys.dll");
154     pPropVariantChangeType = (void *)GetProcAddress(propsys, "PropVariantChangeType");
155
156     if (!pPropVariantChangeType)
157     {
158         ERR("PropVariantChangeType function missing!\n");
159         return ERROR_FUNCTION_FAILED;
160     }
161
162     hr = pPropVariantChangeType(changed, property, 0, vt);
163     return (hr == S_OK) ? ERROR_SUCCESS : ERROR_FUNCTION_FAILED;
164 }
165
166 /* FIXME: doesn't deal with endian conversion */
167 static void read_properties_from_data( PROPVARIANT *prop, LPBYTE data, DWORD sz )
168 {
169     UINT type;
170     DWORD i, size;
171     PROPERTY_DATA *propdata;
172     PROPVARIANT property, *ptr;
173     PROPVARIANT changed;
174     PROPERTYIDOFFSET *idofs;
175     PROPERTYSECTIONHEADER *section_hdr;
176
177     section_hdr = (PROPERTYSECTIONHEADER*) &data[0];
178     idofs = (PROPERTYIDOFFSET*) &data[SECT_HDR_SIZE];
179
180     /* now set all the properties */
181     for( i = 0; i < section_hdr->cProperties; i++ )
182     {
183         if( idofs[i].propid >= MSI_MAX_PROPS )
184         {
185             ERR("Unknown property ID %d\n", idofs[i].propid );
186             break;
187         }
188
189         type = get_type( idofs[i].propid );
190         if( type == VT_EMPTY )
191         {
192             ERR("propid %d has unknown type\n", idofs[i].propid);
193             break;
194         }
195
196         propdata = (PROPERTY_DATA*) &data[ idofs[i].dwOffset ];
197
198         /* check we don't run off the end of the data */
199         size = sz - idofs[i].dwOffset - sizeof(DWORD);
200         if( sizeof(DWORD) > size ||
201             ( propdata->type == VT_FILETIME && sizeof(FILETIME) > size ) ||
202             ( propdata->type == VT_LPSTR && (propdata->u.str.len + sizeof(DWORD)) > size ) )
203         {
204             ERR("not enough data\n");
205             break;
206         }
207
208         property.vt = propdata->type;
209         if( propdata->type == VT_LPSTR )
210         {
211             LPSTR str = msi_alloc( propdata->u.str.len );
212             memcpy( str, propdata->u.str.str, propdata->u.str.len );
213             str[ propdata->u.str.len - 1 ] = 0;
214             property.u.pszVal = str;
215         }
216         else if( propdata->type == VT_FILETIME )
217             property.u.filetime = propdata->u.ft;
218         else if( propdata->type == VT_I2 )
219             property.u.iVal = propdata->u.i2;
220         else if( propdata->type == VT_I4 )
221             property.u.lVal = propdata->u.i4;
222
223         /* check the type is the same as we expect */
224         if( type != propdata->type )
225         {
226             propvar_changetype(&changed, &property, type);
227             ptr = &changed;
228         }
229         else
230             ptr = &property;
231
232         prop[ idofs[i].propid ] = *ptr;
233     }
234 }
235
236 static UINT load_summary_info( MSISUMMARYINFO *si, IStream *stm )
237 {
238     UINT ret = ERROR_FUNCTION_FAILED;
239     PROPERTYSETHEADER set_hdr;
240     FORMATIDOFFSET format_hdr;
241     PROPERTYSECTIONHEADER section_hdr;
242     LPBYTE data = NULL;
243     LARGE_INTEGER ofs;
244     ULONG count, sz;
245     HRESULT r;
246
247     TRACE("%p %p\n", si, stm);
248
249     /* read the header */
250     sz = sizeof set_hdr;
251     r = IStream_Read( stm, &set_hdr, sz, &count );
252     if( FAILED(r) || count != sz )
253         return ret;
254
255     if( set_hdr.wByteOrder != 0xfffe )
256     {
257         ERR("property set not big-endian %04X\n", set_hdr.wByteOrder);
258         return ret;
259     }
260
261     sz = sizeof format_hdr;
262     r = IStream_Read( stm, &format_hdr, sz, &count );
263     if( FAILED(r) || count != sz )
264         return ret;
265
266     /* check the format id is correct */
267     if( !IsEqualGUID( &FMTID_SummaryInformation, &format_hdr.fmtid ) )
268         return ret;
269
270     /* seek to the location of the section */
271     ofs.QuadPart = format_hdr.dwOffset;
272     r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, NULL );
273     if( FAILED(r) )
274         return ret;
275
276     /* read the section itself */
277     sz = SECT_HDR_SIZE;
278     r = IStream_Read( stm, &section_hdr, sz, &count );
279     if( FAILED(r) || count != sz )
280         return ret;
281
282     if( section_hdr.cProperties > MSI_MAX_PROPS )
283     {
284         ERR("too many properties %d\n", section_hdr.cProperties);
285         return ret;
286     }
287
288     data = msi_alloc( section_hdr.cbSection);
289     if( !data )
290         return ret;
291
292     memcpy( data, &section_hdr, SECT_HDR_SIZE );
293
294     /* read all the data in one go */
295     sz = section_hdr.cbSection - SECT_HDR_SIZE;
296     r = IStream_Read( stm, &data[ SECT_HDR_SIZE ], sz, &count );
297     if( SUCCEEDED(r) && count == sz )
298         read_properties_from_data( si->property, data, sz + SECT_HDR_SIZE );
299     else
300         ERR("failed to read properties %d %d\n", count, sz);
301
302     msi_free( data );
303     return ret;
304 }
305
306 static DWORD write_dword( LPBYTE data, DWORD ofs, DWORD val )
307 {
308     if( data )
309     {
310         data[ofs++] = val&0xff;
311         data[ofs++] = (val>>8)&0xff;
312         data[ofs++] = (val>>16)&0xff;
313         data[ofs++] = (val>>24)&0xff;
314     }
315     return 4;
316 }
317
318 static DWORD write_filetime( LPBYTE data, DWORD ofs, const FILETIME *ft )
319 {
320     write_dword( data, ofs, ft->dwLowDateTime );
321     write_dword( data, ofs + 4, ft->dwHighDateTime );
322     return 8;
323 }
324
325 static DWORD write_string( LPBYTE data, DWORD ofs, LPCSTR str )
326 {
327     DWORD len = lstrlenA( str ) + 1;
328     write_dword( data, ofs, len );
329     if( data )
330         memcpy( &data[ofs + 4], str, len );
331     return (7 + len) & ~3;
332 }
333
334 static UINT write_property_to_data( const PROPVARIANT *prop, LPBYTE data )
335 {
336     DWORD sz = 0;
337
338     if( prop->vt == VT_EMPTY )
339         return sz;
340
341     /* add the type */
342     sz += write_dword( data, sz, prop->vt );
343     switch( prop->vt )
344     {
345     case VT_I2:
346         sz += write_dword( data, sz, prop->u.iVal );
347         break;
348     case VT_I4:
349         sz += write_dword( data, sz, prop->u.lVal );
350         break;
351     case VT_FILETIME:
352         sz += write_filetime( data, sz, &prop->u.filetime );
353         break;
354     case VT_LPSTR:
355         sz += write_string( data, sz, prop->u.pszVal );
356         break;
357     }
358     return sz;
359 }
360
361 static UINT save_summary_info( const MSISUMMARYINFO * si, IStream *stm )
362 {
363     UINT ret = ERROR_FUNCTION_FAILED;
364     PROPERTYSETHEADER set_hdr;
365     FORMATIDOFFSET format_hdr;
366     PROPERTYSECTIONHEADER section_hdr;
367     PROPERTYIDOFFSET idofs[MSI_MAX_PROPS];
368     LPBYTE data = NULL;
369     ULONG count, sz;
370     HRESULT r;
371     int i;
372
373     /* write the header */
374     sz = sizeof set_hdr;
375     memset( &set_hdr, 0, sz );
376     set_hdr.wByteOrder = 0xfffe;
377     set_hdr.wFormat = 0;
378     set_hdr.dwOSVer = 0x00020005; /* build 5, platform id 2 */
379     /* set_hdr.clsID is {00000000-0000-0000-0000-000000000000} */
380     set_hdr.reserved = 1;
381     r = IStream_Write( stm, &set_hdr, sz, &count );
382     if( FAILED(r) || count != sz )
383         return ret;
384
385     /* write the format header */
386     sz = sizeof format_hdr;
387     format_hdr.fmtid = FMTID_SummaryInformation;
388     format_hdr.dwOffset = sizeof format_hdr + sizeof set_hdr;
389     r = IStream_Write( stm, &format_hdr, sz, &count );
390     if( FAILED(r) || count != sz )
391         return ret;
392
393     /* add up how much space the data will take and calculate the offsets */
394     section_hdr.cbSection = sizeof section_hdr;
395     section_hdr.cbSection += (get_property_count( si->property ) * sizeof idofs[0]);
396     section_hdr.cProperties = 0;
397     for( i = 0; i < MSI_MAX_PROPS; i++ )
398     {
399         sz = write_property_to_data( &si->property[i], NULL );
400         if( !sz )
401             continue;
402         idofs[ section_hdr.cProperties ].propid = i;
403         idofs[ section_hdr.cProperties ].dwOffset = section_hdr.cbSection;
404         section_hdr.cProperties++;
405         section_hdr.cbSection += sz;
406     }
407
408     data = msi_alloc_zero( section_hdr.cbSection );
409
410     sz = 0;
411     memcpy( &data[sz], &section_hdr, sizeof section_hdr );
412     sz += sizeof section_hdr;
413
414     memcpy( &data[sz], idofs, section_hdr.cProperties * sizeof idofs[0] );
415     sz += section_hdr.cProperties * sizeof idofs[0];
416
417     /* write out the data */
418     for( i = 0; i < MSI_MAX_PROPS; i++ )
419         sz += write_property_to_data( &si->property[i], &data[sz] );
420
421     r = IStream_Write( stm, data, sz, &count );
422     msi_free( data );
423     if( FAILED(r) || count != sz )
424         return ret;
425
426     return ERROR_SUCCESS;
427 }
428
429 MSISUMMARYINFO *MSI_GetSummaryInformationW( IStorage *stg, UINT uiUpdateCount )
430 {
431     IStream *stm = NULL;
432     MSISUMMARYINFO *si;
433     DWORD grfMode;
434     HRESULT r;
435
436     TRACE("%p %d\n", stg, uiUpdateCount );
437
438     si = alloc_msiobject( MSIHANDLETYPE_SUMMARYINFO, 
439                   sizeof (MSISUMMARYINFO), MSI_CloseSummaryInfo );
440     if( !si )
441         return si;
442
443     si->update_count = uiUpdateCount;
444     IStorage_AddRef( stg );
445     si->storage = stg;
446
447     /* read the stream... if we fail, we'll start with an empty property set */
448     grfMode = STGM_READ | STGM_SHARE_EXCLUSIVE;
449     r = IStorage_OpenStream( si->storage, szSumInfo, 0, grfMode, 0, &stm );
450     if( SUCCEEDED(r) )
451     {
452         load_summary_info( si, stm );
453         IStream_Release( stm );
454     }
455
456     return si;
457 }
458
459 UINT WINAPI MsiGetSummaryInformationW( MSIHANDLE hDatabase, 
460               LPCWSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle )
461 {
462     MSISUMMARYINFO *si;
463     MSIDATABASE *db;
464     UINT ret = ERROR_FUNCTION_FAILED;
465
466     TRACE("%d %s %d %p\n", hDatabase, debugstr_w(szDatabase),
467            uiUpdateCount, pHandle);
468
469     if( !pHandle )
470         return ERROR_INVALID_PARAMETER;
471
472     if( szDatabase )
473     {
474         LPCWSTR persist = uiUpdateCount ? MSIDBOPEN_TRANSACT : MSIDBOPEN_READONLY;
475
476         ret = MSI_OpenDatabaseW( szDatabase, persist, &db );
477         if( ret != ERROR_SUCCESS )
478             return ret;
479     }
480     else
481     {
482         db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
483         if( !db )
484         {
485             HRESULT hr;
486             IWineMsiRemoteDatabase *remote_database;
487
488             remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hDatabase );
489             if ( !remote_database )
490                 return ERROR_INVALID_HANDLE;
491
492             hr = IWineMsiRemoteDatabase_GetSummaryInformation( remote_database,
493                                                                uiUpdateCount, pHandle );
494             IWineMsiRemoteDatabase_Release( remote_database );
495
496             if (FAILED(hr))
497             {
498                 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
499                     return HRESULT_CODE(hr);
500
501                 return ERROR_FUNCTION_FAILED;
502             }
503
504             return ERROR_SUCCESS;
505         }
506     }
507
508     si = MSI_GetSummaryInformationW( db->storage, uiUpdateCount );
509     if (si)
510     {
511         *pHandle = alloc_msihandle( &si->hdr );
512         if( *pHandle )
513             ret = ERROR_SUCCESS;
514         else
515             ret = ERROR_NOT_ENOUGH_MEMORY;
516         msiobj_release( &si->hdr );
517     }
518
519     if( db )
520         msiobj_release( &db->hdr );
521
522     return ret;
523 }
524
525 UINT WINAPI MsiGetSummaryInformationA(MSIHANDLE hDatabase, 
526               LPCSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle)
527 {
528     LPWSTR szwDatabase = NULL;
529     UINT ret;
530
531     TRACE("%d %s %d %p\n", hDatabase, debugstr_a(szDatabase),
532           uiUpdateCount, pHandle);
533
534     if( szDatabase )
535     {
536         szwDatabase = strdupAtoW( szDatabase );
537         if( !szwDatabase )
538             return ERROR_FUNCTION_FAILED;
539     }
540
541     ret = MsiGetSummaryInformationW(hDatabase, szwDatabase, uiUpdateCount, pHandle);
542
543     msi_free( szwDatabase );
544
545     return ret;
546 }
547
548 UINT WINAPI MsiSummaryInfoGetPropertyCount(MSIHANDLE hSummaryInfo, PUINT pCount)
549 {
550     MSISUMMARYINFO *si;
551
552     TRACE("%d %p\n", hSummaryInfo, pCount);
553
554     si = msihandle2msiinfo( hSummaryInfo, MSIHANDLETYPE_SUMMARYINFO );
555     if( !si )
556         return ERROR_INVALID_HANDLE;
557
558     if( pCount )
559         *pCount = get_property_count( si->property );
560     msiobj_release( &si->hdr );
561
562     return ERROR_SUCCESS;
563 }
564
565 static UINT get_prop( MSIHANDLE handle, UINT uiProperty, UINT *puiDataType,
566           INT *piValue, FILETIME *pftValue, awstring *str, DWORD *pcchValueBuf)
567 {
568     MSISUMMARYINFO *si;
569     PROPVARIANT *prop;
570     UINT ret = ERROR_SUCCESS;
571
572     TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
573           piValue, pftValue, str, pcchValueBuf);
574
575     if ( uiProperty >= MSI_MAX_PROPS )
576     {
577         if (puiDataType) *puiDataType = VT_EMPTY;
578         return ERROR_UNKNOWN_PROPERTY;
579     }
580
581     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
582     if( !si )
583         return ERROR_INVALID_HANDLE;
584
585     prop = &si->property[uiProperty];
586
587     if( puiDataType )
588         *puiDataType = prop->vt;
589
590     switch( prop->vt )
591     {
592     case VT_I2:
593         if( piValue )
594             *piValue = prop->u.iVal;
595         break;
596     case VT_I4:
597         if( piValue )
598             *piValue = prop->u.lVal;
599         break;
600     case VT_LPSTR:
601         if( pcchValueBuf )
602         {
603             DWORD len = 0;
604
605             if( str->unicode )
606             {
607                 len = MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1, NULL, 0 ) - 1;
608                 MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1, str->str.w, *pcchValueBuf );
609             }
610             else
611             {
612                 len = lstrlenA( prop->u.pszVal );
613                 if( str->str.a )
614                     lstrcpynA(str->str.a, prop->u.pszVal, *pcchValueBuf );
615             }
616             if (len >= *pcchValueBuf)
617                 ret = ERROR_MORE_DATA;
618             *pcchValueBuf = len;
619         }
620         break;
621     case VT_FILETIME:
622         if( pftValue )
623             *pftValue = prop->u.filetime;
624         break;
625     case VT_EMPTY:
626         break;
627     default:
628         FIXME("Unknown property variant type\n");
629         break;
630     }
631     msiobj_release( &si->hdr );
632     return ret;
633 }
634
635 LPWSTR msi_suminfo_dup_string( MSISUMMARYINFO *si, UINT uiProperty )
636 {
637     PROPVARIANT *prop;
638
639     if ( uiProperty >= MSI_MAX_PROPS )
640         return NULL;
641     prop = &si->property[uiProperty];
642     if( prop->vt != VT_LPSTR )
643         return NULL;
644     return strdupAtoW( prop->u.pszVal );
645 }
646
647 LPWSTR msi_get_suminfo_product( IStorage *stg )
648 {
649     MSISUMMARYINFO *si;
650     LPWSTR prod;
651
652     si = MSI_GetSummaryInformationW( stg, 0 );
653     if (!si)
654     {
655         ERR("no summary information!\n");
656         return NULL;
657     }
658     prod = msi_suminfo_dup_string( si, PID_REVNUMBER );
659     msiobj_release( &si->hdr );
660     return prod;
661 }
662
663 UINT WINAPI MsiSummaryInfoGetPropertyA(
664       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
665       FILETIME *pftValue, LPSTR szValueBuf, LPDWORD pcchValueBuf)
666 {
667     awstring str;
668
669     TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
670           piValue, pftValue, szValueBuf, pcchValueBuf );
671
672     str.unicode = FALSE;
673     str.str.a = szValueBuf;
674
675     return get_prop( handle, uiProperty, puiDataType, piValue,
676                      pftValue, &str, pcchValueBuf );
677 }
678
679 UINT WINAPI MsiSummaryInfoGetPropertyW(
680       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
681       FILETIME *pftValue, LPWSTR szValueBuf, LPDWORD pcchValueBuf)
682 {
683     awstring str;
684
685     TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
686           piValue, pftValue, szValueBuf, pcchValueBuf );
687
688     str.unicode = TRUE;
689     str.str.w = szValueBuf;
690
691     return get_prop( handle, uiProperty, puiDataType, piValue,
692                      pftValue, &str, pcchValueBuf );
693 }
694
695 static UINT set_prop( MSISUMMARYINFO *si, UINT uiProperty, UINT type,
696                INT iValue, FILETIME* pftValue, awcstring *str )
697 {
698     PROPVARIANT *prop;
699     UINT len;
700
701     TRACE("%p %u %u %i %p %p\n", si, uiProperty, type, iValue,
702           pftValue, str );
703
704     prop = &si->property[uiProperty];
705
706     if( prop->vt == VT_EMPTY )
707     {
708         if( !si->update_count )
709             return ERROR_FUNCTION_FAILED;
710
711         si->update_count--;
712     }
713     else if( prop->vt != type )
714         return ERROR_SUCCESS;
715
716     free_prop( prop );
717     prop->vt = type;
718     switch( type )
719     {
720     case VT_I4:
721         prop->u.lVal = iValue;
722         break;
723     case VT_I2:
724         prop->u.iVal = iValue;
725         break;
726     case VT_FILETIME:
727         prop->u.filetime = *pftValue;
728         break;
729     case VT_LPSTR:
730         if( str->unicode )
731         {
732             len = WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
733                                        NULL, 0, NULL, NULL );
734             prop->u.pszVal = msi_alloc( len );
735             WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
736                                  prop->u.pszVal, len, NULL, NULL );
737         }
738         else
739         {
740             len = lstrlenA( str->str.a ) + 1;
741             prop->u.pszVal = msi_alloc( len );
742             lstrcpyA( prop->u.pszVal, str->str.a );
743         }
744         break;
745     }
746
747     return ERROR_SUCCESS;
748 }
749
750 UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty,
751                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCWSTR szValue )
752 {
753     awcstring str;
754     MSISUMMARYINFO *si;
755     UINT type, ret;
756
757     TRACE("%d %u %u %i %p %s\n", handle, uiProperty, uiDataType,
758           iValue, pftValue, debugstr_w(szValue) );
759
760     type = get_type( uiProperty );
761     if( type == VT_EMPTY || type != uiDataType )
762         return ERROR_DATATYPE_MISMATCH;
763
764     if( uiDataType == VT_LPSTR && !szValue )
765         return ERROR_INVALID_PARAMETER;
766
767     if( uiDataType == VT_FILETIME && !pftValue )
768         return ERROR_INVALID_PARAMETER;
769
770     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
771     if( !si )
772         return ERROR_INVALID_HANDLE;
773
774     str.unicode = TRUE;
775     str.str.w = szValue;
776     ret = set_prop( si, uiProperty, type, iValue, pftValue, &str );
777
778     msiobj_release( &si->hdr );
779     return ret;
780 }
781
782 UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty,
783                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCSTR szValue )
784 {
785     awcstring str;
786     MSISUMMARYINFO *si;
787     UINT type, ret;
788
789     TRACE("%d %u %u %i %p %s\n", handle, uiProperty, uiDataType,
790           iValue, pftValue, debugstr_a(szValue) );
791
792     type = get_type( uiProperty );
793     if( type == VT_EMPTY || type != uiDataType )
794         return ERROR_DATATYPE_MISMATCH;
795
796     if( uiDataType == VT_LPSTR && !szValue )
797         return ERROR_INVALID_PARAMETER;
798
799     if( uiDataType == VT_FILETIME && !pftValue )
800         return ERROR_INVALID_PARAMETER;
801
802     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
803     if( !si )
804         return ERROR_INVALID_HANDLE;
805
806     str.unicode = FALSE;
807     str.str.a = szValue;
808     ret = set_prop( si, uiProperty, uiDataType, iValue, pftValue, &str );
809
810     msiobj_release( &si->hdr );
811     return ret;
812 }
813
814 static UINT suminfo_persist( MSISUMMARYINFO *si )
815 {
816     UINT ret = ERROR_FUNCTION_FAILED;
817     IStream *stm = NULL;
818     DWORD grfMode;
819     HRESULT r;
820
821     grfMode = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
822     r = IStorage_CreateStream( si->storage, szSumInfo, grfMode, 0, 0, &stm );
823     if( SUCCEEDED(r) )
824     {
825         ret = save_summary_info( si, stm );
826         IStream_Release( stm );
827     }
828     return ret;
829 }
830
831 static void parse_filetime( LPCWSTR str, FILETIME *ft )
832 {
833     SYSTEMTIME lt, utc;
834     const WCHAR *p = str;
835     WCHAR *end;
836
837     memset( &lt, 0, sizeof(lt) );
838
839     /* YYYY/MM/DD hh:mm:ss */
840
841     while (isspaceW( *p )) p++;
842
843     lt.wYear = strtolW( p, &end, 10 );
844     if (*end != '/') return;
845     p = end + 1;
846
847     lt.wMonth = strtolW( p, &end, 10 );
848     if (*end != '/') return;
849     p = end + 1;
850
851     lt.wDay = strtolW( p, &end, 10 );
852     if (*end != ' ') return;
853     p = end + 1;
854
855     while (isspaceW( *p )) p++;
856
857     lt.wHour = strtolW( p, &end, 10 );
858     if (*end != ':') return;
859     p = end + 1;
860
861     lt.wMinute = strtolW( p, &end, 10 );
862     if (*end != ':') return;
863     p = end + 1;
864
865     lt.wSecond = strtolW( p, &end, 10 );
866
867     TzSpecificLocalTimeToSystemTime( NULL, &lt, &utc );
868     SystemTimeToFileTime( &utc, ft );
869 }
870
871 static UINT parse_prop( LPCWSTR prop, LPCWSTR value, UINT *pid, INT *int_value,
872                         FILETIME *ft_value, awcstring *str_value )
873 {
874     *pid = atoiW( prop );
875     switch (*pid)
876     {
877     case PID_CODEPAGE:
878     case PID_WORDCOUNT:
879     case PID_CHARCOUNT:
880     case PID_SECURITY:
881     case PID_PAGECOUNT:
882         *int_value = atoiW( value );
883         break;
884
885     case PID_LASTPRINTED:
886     case PID_CREATE_DTM:
887     case PID_LASTSAVE_DTM:
888         parse_filetime( value, ft_value );
889         break;
890
891     case PID_SUBJECT:
892     case PID_AUTHOR:
893     case PID_KEYWORDS:
894     case PID_COMMENTS:
895     case PID_TEMPLATE:
896     case PID_LASTAUTHOR:
897     case PID_REVNUMBER:
898     case PID_APPNAME:
899     case PID_TITLE:
900         str_value->str.w = value;
901         str_value->unicode = TRUE;
902         break;
903
904     default:
905         WARN("unhandled prop id %u\n", *pid);
906         return ERROR_FUNCTION_FAILED;
907     }
908
909     return ERROR_SUCCESS;
910 }
911
912 UINT msi_add_suminfo( MSIDATABASE *db, LPWSTR **records, int num_records, int num_columns )
913 {
914     UINT r = ERROR_FUNCTION_FAILED;
915     DWORD i, j;
916     MSISUMMARYINFO *si;
917
918     si = MSI_GetSummaryInformationW( db->storage, num_records * (num_columns / 2) );
919     if (!si)
920     {
921         ERR("no summary information!\n");
922         return ERROR_FUNCTION_FAILED;
923     }
924
925     for (i = 0; i < num_records; i++)
926     {
927         for (j = 0; j < num_columns; j += 2)
928         {
929             UINT pid;
930             INT int_value = 0;
931             FILETIME ft_value;
932             awcstring str_value;
933
934             r = parse_prop( records[i][j], records[i][j + 1], &pid, &int_value, &ft_value, &str_value );
935             if (r != ERROR_SUCCESS)
936                 goto end;
937
938             r = set_prop( si, pid, get_type(pid), int_value, &ft_value, &str_value );
939             if (r != ERROR_SUCCESS)
940                 goto end;
941         }
942     }
943
944 end:
945     if (r == ERROR_SUCCESS)
946         r = suminfo_persist( si );
947
948     msiobj_release( &si->hdr );
949     return r;
950 }
951
952 UINT WINAPI MsiSummaryInfoPersist( MSIHANDLE handle )
953 {
954     MSISUMMARYINFO *si;
955     UINT ret;
956
957     TRACE("%d\n", handle );
958
959     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
960     if( !si )
961         return ERROR_INVALID_HANDLE;
962
963     ret = suminfo_persist( si );
964
965     msiobj_release( &si->hdr );
966     return ret;
967 }