msi: Add an offset to sequence numbers belonging to files added by a patch.
[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 && szDatabase[0] )
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 INT msi_suminfo_get_int32( MSISUMMARYINFO *si, UINT uiProperty )
648 {
649     PROPVARIANT *prop;
650
651     if ( uiProperty >= MSI_MAX_PROPS )
652         return -1;
653     prop = &si->property[uiProperty];
654     if( prop->vt != VT_I4 )
655         return -1;
656     return prop->u.lVal;
657 }
658
659 LPWSTR msi_get_suminfo_product( IStorage *stg )
660 {
661     MSISUMMARYINFO *si;
662     LPWSTR prod;
663
664     si = MSI_GetSummaryInformationW( stg, 0 );
665     if (!si)
666     {
667         ERR("no summary information!\n");
668         return NULL;
669     }
670     prod = msi_suminfo_dup_string( si, PID_REVNUMBER );
671     msiobj_release( &si->hdr );
672     return prod;
673 }
674
675 UINT WINAPI MsiSummaryInfoGetPropertyA(
676       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
677       FILETIME *pftValue, LPSTR szValueBuf, LPDWORD pcchValueBuf)
678 {
679     awstring str;
680
681     TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
682           piValue, pftValue, szValueBuf, pcchValueBuf );
683
684     str.unicode = FALSE;
685     str.str.a = szValueBuf;
686
687     return get_prop( handle, uiProperty, puiDataType, piValue,
688                      pftValue, &str, pcchValueBuf );
689 }
690
691 UINT WINAPI MsiSummaryInfoGetPropertyW(
692       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
693       FILETIME *pftValue, LPWSTR szValueBuf, LPDWORD pcchValueBuf)
694 {
695     awstring str;
696
697     TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
698           piValue, pftValue, szValueBuf, pcchValueBuf );
699
700     str.unicode = TRUE;
701     str.str.w = szValueBuf;
702
703     return get_prop( handle, uiProperty, puiDataType, piValue,
704                      pftValue, &str, pcchValueBuf );
705 }
706
707 static UINT set_prop( MSISUMMARYINFO *si, UINT uiProperty, UINT type,
708                INT iValue, FILETIME* pftValue, awcstring *str )
709 {
710     PROPVARIANT *prop;
711     UINT len;
712
713     TRACE("%p %u %u %i %p %p\n", si, uiProperty, type, iValue,
714           pftValue, str );
715
716     prop = &si->property[uiProperty];
717
718     if( prop->vt == VT_EMPTY )
719     {
720         if( !si->update_count )
721             return ERROR_FUNCTION_FAILED;
722
723         si->update_count--;
724     }
725     else if( prop->vt != type )
726         return ERROR_SUCCESS;
727
728     free_prop( prop );
729     prop->vt = type;
730     switch( type )
731     {
732     case VT_I4:
733         prop->u.lVal = iValue;
734         break;
735     case VT_I2:
736         prop->u.iVal = iValue;
737         break;
738     case VT_FILETIME:
739         prop->u.filetime = *pftValue;
740         break;
741     case VT_LPSTR:
742         if( str->unicode )
743         {
744             len = WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
745                                        NULL, 0, NULL, NULL );
746             prop->u.pszVal = msi_alloc( len );
747             WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
748                                  prop->u.pszVal, len, NULL, NULL );
749         }
750         else
751         {
752             len = lstrlenA( str->str.a ) + 1;
753             prop->u.pszVal = msi_alloc( len );
754             lstrcpyA( prop->u.pszVal, str->str.a );
755         }
756         break;
757     }
758
759     return ERROR_SUCCESS;
760 }
761
762 UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty,
763                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCWSTR szValue )
764 {
765     awcstring str;
766     MSISUMMARYINFO *si;
767     UINT type, ret;
768
769     TRACE("%d %u %u %i %p %s\n", handle, uiProperty, uiDataType,
770           iValue, pftValue, debugstr_w(szValue) );
771
772     type = get_type( uiProperty );
773     if( type == VT_EMPTY || type != uiDataType )
774         return ERROR_DATATYPE_MISMATCH;
775
776     if( uiDataType == VT_LPSTR && !szValue )
777         return ERROR_INVALID_PARAMETER;
778
779     if( uiDataType == VT_FILETIME && !pftValue )
780         return ERROR_INVALID_PARAMETER;
781
782     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
783     if( !si )
784         return ERROR_INVALID_HANDLE;
785
786     str.unicode = TRUE;
787     str.str.w = szValue;
788     ret = set_prop( si, uiProperty, type, iValue, pftValue, &str );
789
790     msiobj_release( &si->hdr );
791     return ret;
792 }
793
794 UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty,
795                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCSTR szValue )
796 {
797     awcstring str;
798     MSISUMMARYINFO *si;
799     UINT type, ret;
800
801     TRACE("%d %u %u %i %p %s\n", handle, uiProperty, uiDataType,
802           iValue, pftValue, debugstr_a(szValue) );
803
804     type = get_type( uiProperty );
805     if( type == VT_EMPTY || type != uiDataType )
806         return ERROR_DATATYPE_MISMATCH;
807
808     if( uiDataType == VT_LPSTR && !szValue )
809         return ERROR_INVALID_PARAMETER;
810
811     if( uiDataType == VT_FILETIME && !pftValue )
812         return ERROR_INVALID_PARAMETER;
813
814     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
815     if( !si )
816         return ERROR_INVALID_HANDLE;
817
818     str.unicode = FALSE;
819     str.str.a = szValue;
820     ret = set_prop( si, uiProperty, uiDataType, iValue, pftValue, &str );
821
822     msiobj_release( &si->hdr );
823     return ret;
824 }
825
826 static UINT suminfo_persist( MSISUMMARYINFO *si )
827 {
828     UINT ret = ERROR_FUNCTION_FAILED;
829     IStream *stm = NULL;
830     DWORD grfMode;
831     HRESULT r;
832
833     grfMode = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
834     r = IStorage_CreateStream( si->storage, szSumInfo, grfMode, 0, 0, &stm );
835     if( SUCCEEDED(r) )
836     {
837         ret = save_summary_info( si, stm );
838         IStream_Release( stm );
839     }
840     return ret;
841 }
842
843 static void parse_filetime( LPCWSTR str, FILETIME *ft )
844 {
845     SYSTEMTIME lt, utc;
846     const WCHAR *p = str;
847     WCHAR *end;
848
849     memset( &lt, 0, sizeof(lt) );
850
851     /* YYYY/MM/DD hh:mm:ss */
852
853     while (isspaceW( *p )) p++;
854
855     lt.wYear = strtolW( p, &end, 10 );
856     if (*end != '/') return;
857     p = end + 1;
858
859     lt.wMonth = strtolW( p, &end, 10 );
860     if (*end != '/') return;
861     p = end + 1;
862
863     lt.wDay = strtolW( p, &end, 10 );
864     if (*end != ' ') return;
865     p = end + 1;
866
867     while (isspaceW( *p )) p++;
868
869     lt.wHour = strtolW( p, &end, 10 );
870     if (*end != ':') return;
871     p = end + 1;
872
873     lt.wMinute = strtolW( p, &end, 10 );
874     if (*end != ':') return;
875     p = end + 1;
876
877     lt.wSecond = strtolW( p, &end, 10 );
878
879     TzSpecificLocalTimeToSystemTime( NULL, &lt, &utc );
880     SystemTimeToFileTime( &utc, ft );
881 }
882
883 static UINT parse_prop( LPCWSTR prop, LPCWSTR value, UINT *pid, INT *int_value,
884                         FILETIME *ft_value, awcstring *str_value )
885 {
886     *pid = atoiW( prop );
887     switch (*pid)
888     {
889     case PID_CODEPAGE:
890     case PID_WORDCOUNT:
891     case PID_CHARCOUNT:
892     case PID_SECURITY:
893     case PID_PAGECOUNT:
894         *int_value = atoiW( value );
895         break;
896
897     case PID_LASTPRINTED:
898     case PID_CREATE_DTM:
899     case PID_LASTSAVE_DTM:
900         parse_filetime( value, ft_value );
901         break;
902
903     case PID_SUBJECT:
904     case PID_AUTHOR:
905     case PID_KEYWORDS:
906     case PID_COMMENTS:
907     case PID_TEMPLATE:
908     case PID_LASTAUTHOR:
909     case PID_REVNUMBER:
910     case PID_APPNAME:
911     case PID_TITLE:
912         str_value->str.w = value;
913         str_value->unicode = TRUE;
914         break;
915
916     default:
917         WARN("unhandled prop id %u\n", *pid);
918         return ERROR_FUNCTION_FAILED;
919     }
920
921     return ERROR_SUCCESS;
922 }
923
924 UINT msi_add_suminfo( MSIDATABASE *db, LPWSTR **records, int num_records, int num_columns )
925 {
926     UINT r = ERROR_FUNCTION_FAILED;
927     DWORD i, j;
928     MSISUMMARYINFO *si;
929
930     si = MSI_GetSummaryInformationW( db->storage, num_records * (num_columns / 2) );
931     if (!si)
932     {
933         ERR("no summary information!\n");
934         return ERROR_FUNCTION_FAILED;
935     }
936
937     for (i = 0; i < num_records; i++)
938     {
939         for (j = 0; j < num_columns; j += 2)
940         {
941             UINT pid;
942             INT int_value = 0;
943             FILETIME ft_value;
944             awcstring str_value;
945
946             r = parse_prop( records[i][j], records[i][j + 1], &pid, &int_value, &ft_value, &str_value );
947             if (r != ERROR_SUCCESS)
948                 goto end;
949
950             r = set_prop( si, pid, get_type(pid), int_value, &ft_value, &str_value );
951             if (r != ERROR_SUCCESS)
952                 goto end;
953         }
954     }
955
956 end:
957     if (r == ERROR_SUCCESS)
958         r = suminfo_persist( si );
959
960     msiobj_release( &si->hdr );
961     return r;
962 }
963
964 UINT WINAPI MsiSummaryInfoPersist( MSIHANDLE handle )
965 {
966     MSISUMMARYINFO *si;
967     UINT ret;
968
969     TRACE("%d\n", handle );
970
971     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
972     if( !si )
973         return ERROR_INVALID_HANDLE;
974
975     ret = suminfo_persist( si );
976
977     msiobj_release( &si->hdr );
978     return ret;
979 }