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