shlwapi: Use proper helpers for iface calls.
[wine/multimedia.git] / dlls / msi / suminfo.c
blobe0c99b8b488109d5ef0ef9b94e92c417dc743a3f
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
4 * Copyright 2002, 2005 Mike McCormack for CodeWeavers
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.
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.
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
21 #include <stdarg.h>
23 #define COBJMACROS
24 #define NONAMELESSUNION
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"
41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
43 #include "pshpack1.h"
45 typedef struct {
46 WORD wByteOrder;
47 WORD wFormat;
48 DWORD dwOSVer;
49 CLSID clsID;
50 DWORD reserved;
51 } PROPERTYSETHEADER;
53 typedef struct {
54 FMTID fmtid;
55 DWORD dwOffset;
56 } FORMATIDOFFSET;
58 typedef struct {
59 DWORD cbSection;
60 DWORD cProperties;
61 } PROPERTYSECTIONHEADER;
63 typedef struct {
64 DWORD propid;
65 DWORD dwOffset;
66 } PROPERTYIDOFFSET;
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;
81 #include "poppack.h"
83 static HRESULT (WINAPI *pPropVariantChangeType)
84 (PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
85 PROPVAR_CHANGE_FLAGS flags, VARTYPE vt);
87 #define SECT_HDR_SIZE (sizeof(PROPERTYSECTIONHEADER))
89 static void free_prop( PROPVARIANT *prop )
91 if (prop->vt == VT_LPSTR )
92 msi_free( prop->u.pszVal );
93 prop->vt = VT_EMPTY;
96 static void MSI_CloseSummaryInfo( MSIOBJECTHDR *arg )
98 MSISUMMARYINFO *si = (MSISUMMARYINFO *) arg;
99 DWORD i;
101 for( i = 0; i < MSI_MAX_PROPS; i++ )
102 free_prop( &si->property[i] );
103 IStorage_Release( si->storage );
106 static UINT get_type( UINT uiProperty )
108 switch( uiProperty )
110 case PID_CODEPAGE:
111 return VT_I2;
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;
124 case PID_LASTPRINTED:
125 case PID_CREATE_DTM:
126 case PID_LASTSAVE_DTM:
127 return VT_FILETIME;
129 case PID_WORDCOUNT:
130 case PID_CHARCOUNT:
131 case PID_SECURITY:
132 case PID_PAGECOUNT:
133 return VT_I4;
135 return VT_EMPTY;
138 static UINT get_property_count( const PROPVARIANT *property )
140 UINT i, n = 0;
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;
150 static UINT propvar_changetype(PROPVARIANT *changed, PROPVARIANT *property, VARTYPE vt)
152 HRESULT hr;
153 HMODULE propsys = LoadLibraryA("propsys.dll");
154 pPropVariantChangeType = (void *)GetProcAddress(propsys, "PropVariantChangeType");
156 if (!pPropVariantChangeType)
158 ERR("PropVariantChangeType function missing!\n");
159 return ERROR_FUNCTION_FAILED;
162 hr = pPropVariantChangeType(changed, property, 0, vt);
163 return (hr == S_OK) ? ERROR_SUCCESS : ERROR_FUNCTION_FAILED;
166 /* FIXME: doesn't deal with endian conversion */
167 static void read_properties_from_data( PROPVARIANT *prop, LPBYTE data, DWORD sz )
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;
177 section_hdr = (PROPERTYSECTIONHEADER*) &data[0];
178 idofs = (PROPERTYIDOFFSET*) &data[SECT_HDR_SIZE];
180 /* now set all the properties */
181 for( i = 0; i < section_hdr->cProperties; i++ )
183 if( idofs[i].propid >= MSI_MAX_PROPS )
185 ERR("Unknown property ID %d\n", idofs[i].propid );
186 break;
189 type = get_type( idofs[i].propid );
190 if( type == VT_EMPTY )
192 ERR("propid %d has unknown type\n", idofs[i].propid);
193 break;
196 propdata = (PROPERTY_DATA*) &data[ idofs[i].dwOffset ];
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 ) )
204 ERR("not enough data\n");
205 break;
208 property.vt = propdata->type;
209 if( propdata->type == VT_LPSTR )
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;
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;
223 /* check the type is the same as we expect */
224 if( type != propdata->type )
226 propvar_changetype(&changed, &property, type);
227 ptr = &changed;
229 else
230 ptr = &property;
232 prop[ idofs[i].propid ] = *ptr;
236 static UINT load_summary_info( MSISUMMARYINFO *si, IStream *stm )
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;
247 TRACE("%p %p\n", si, stm);
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;
255 if( set_hdr.wByteOrder != 0xfffe )
257 ERR("property set not big-endian %04X\n", set_hdr.wByteOrder);
258 return ret;
261 sz = sizeof format_hdr;
262 r = IStream_Read( stm, &format_hdr, sz, &count );
263 if( FAILED(r) || count != sz )
264 return ret;
266 /* check the format id is correct */
267 if( !IsEqualGUID( &FMTID_SummaryInformation, &format_hdr.fmtid ) )
268 return ret;
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;
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;
282 if( section_hdr.cProperties > MSI_MAX_PROPS )
284 ERR("too many properties %d\n", section_hdr.cProperties);
285 return ret;
288 data = msi_alloc( section_hdr.cbSection);
289 if( !data )
290 return ret;
292 memcpy( data, &section_hdr, SECT_HDR_SIZE );
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);
302 msi_free( data );
303 return ret;
306 static DWORD write_dword( LPBYTE data, DWORD ofs, DWORD val )
308 if( data )
310 data[ofs++] = val&0xff;
311 data[ofs++] = (val>>8)&0xff;
312 data[ofs++] = (val>>16)&0xff;
313 data[ofs++] = (val>>24)&0xff;
315 return 4;
318 static DWORD write_filetime( LPBYTE data, DWORD ofs, const FILETIME *ft )
320 write_dword( data, ofs, ft->dwLowDateTime );
321 write_dword( data, ofs + 4, ft->dwHighDateTime );
322 return 8;
325 static DWORD write_string( LPBYTE data, DWORD ofs, LPCSTR str )
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;
334 static UINT write_property_to_data( const PROPVARIANT *prop, LPBYTE data )
336 DWORD sz = 0;
338 if( prop->vt == VT_EMPTY )
339 return sz;
341 /* add the type */
342 sz += write_dword( data, sz, prop->vt );
343 switch( prop->vt )
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;
358 return sz;
361 static UINT save_summary_info( const MSISUMMARYINFO * si, IStream *stm )
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;
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;
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;
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++ )
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;
408 data = msi_alloc_zero( section_hdr.cbSection );
410 sz = 0;
411 memcpy( &data[sz], &section_hdr, sizeof section_hdr );
412 sz += sizeof section_hdr;
414 memcpy( &data[sz], idofs, section_hdr.cProperties * sizeof idofs[0] );
415 sz += section_hdr.cProperties * sizeof idofs[0];
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] );
421 r = IStream_Write( stm, data, sz, &count );
422 msi_free( data );
423 if( FAILED(r) || count != sz )
424 return ret;
426 return ERROR_SUCCESS;
429 MSISUMMARYINFO *MSI_GetSummaryInformationW( IStorage *stg, UINT uiUpdateCount )
431 IStream *stm = NULL;
432 MSISUMMARYINFO *si;
433 DWORD grfMode;
434 HRESULT r;
436 TRACE("%p %d\n", stg, uiUpdateCount );
438 si = alloc_msiobject( MSIHANDLETYPE_SUMMARYINFO,
439 sizeof (MSISUMMARYINFO), MSI_CloseSummaryInfo );
440 if( !si )
441 return si;
443 si->update_count = uiUpdateCount;
444 IStorage_AddRef( stg );
445 si->storage = stg;
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) )
452 load_summary_info( si, stm );
453 IStream_Release( stm );
456 return si;
459 UINT WINAPI MsiGetSummaryInformationW( MSIHANDLE hDatabase,
460 LPCWSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle )
462 MSISUMMARYINFO *si;
463 MSIDATABASE *db;
464 UINT ret = ERROR_FUNCTION_FAILED;
466 TRACE("%d %s %d %p\n", hDatabase, debugstr_w(szDatabase),
467 uiUpdateCount, pHandle);
469 if( !pHandle )
470 return ERROR_INVALID_PARAMETER;
472 if( szDatabase && szDatabase[0] )
474 LPCWSTR persist = uiUpdateCount ? MSIDBOPEN_TRANSACT : MSIDBOPEN_READONLY;
476 ret = MSI_OpenDatabaseW( szDatabase, persist, &db );
477 if( ret != ERROR_SUCCESS )
478 return ret;
480 else
482 db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
483 if( !db )
485 HRESULT hr;
486 IWineMsiRemoteDatabase *remote_database;
488 remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hDatabase );
489 if ( !remote_database )
490 return ERROR_INVALID_HANDLE;
492 hr = IWineMsiRemoteDatabase_GetSummaryInformation( remote_database,
493 uiUpdateCount, pHandle );
494 IWineMsiRemoteDatabase_Release( remote_database );
496 if (FAILED(hr))
498 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
499 return HRESULT_CODE(hr);
501 return ERROR_FUNCTION_FAILED;
504 return ERROR_SUCCESS;
508 si = MSI_GetSummaryInformationW( db->storage, uiUpdateCount );
509 if (si)
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 );
519 msiobj_release( &db->hdr );
520 return ret;
523 UINT WINAPI MsiGetSummaryInformationA(MSIHANDLE hDatabase,
524 LPCSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle)
526 LPWSTR szwDatabase = NULL;
527 UINT ret;
529 TRACE("%d %s %d %p\n", hDatabase, debugstr_a(szDatabase),
530 uiUpdateCount, pHandle);
532 if( szDatabase )
534 szwDatabase = strdupAtoW( szDatabase );
535 if( !szwDatabase )
536 return ERROR_FUNCTION_FAILED;
539 ret = MsiGetSummaryInformationW(hDatabase, szwDatabase, uiUpdateCount, pHandle);
541 msi_free( szwDatabase );
543 return ret;
546 UINT WINAPI MsiSummaryInfoGetPropertyCount(MSIHANDLE hSummaryInfo, PUINT pCount)
548 MSISUMMARYINFO *si;
550 TRACE("%d %p\n", hSummaryInfo, pCount);
552 si = msihandle2msiinfo( hSummaryInfo, MSIHANDLETYPE_SUMMARYINFO );
553 if( !si )
554 return ERROR_INVALID_HANDLE;
556 if( pCount )
557 *pCount = get_property_count( si->property );
558 msiobj_release( &si->hdr );
560 return ERROR_SUCCESS;
563 static UINT get_prop( MSIHANDLE handle, UINT uiProperty, UINT *puiDataType,
564 INT *piValue, FILETIME *pftValue, awstring *str, DWORD *pcchValueBuf)
566 MSISUMMARYINFO *si;
567 PROPVARIANT *prop;
568 UINT ret = ERROR_SUCCESS;
570 TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
571 piValue, pftValue, str, pcchValueBuf);
573 if ( uiProperty >= MSI_MAX_PROPS )
575 if (puiDataType) *puiDataType = VT_EMPTY;
576 return ERROR_UNKNOWN_PROPERTY;
579 si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
580 if( !si )
581 return ERROR_INVALID_HANDLE;
583 prop = &si->property[uiProperty];
585 if( puiDataType )
586 *puiDataType = prop->vt;
588 switch( prop->vt )
590 case VT_I2:
591 if( piValue )
592 *piValue = prop->u.iVal;
593 break;
594 case VT_I4:
595 if( piValue )
596 *piValue = prop->u.lVal;
597 break;
598 case VT_LPSTR:
599 if( pcchValueBuf )
601 DWORD len = 0;
603 if( str->unicode )
605 len = MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1, NULL, 0 ) - 1;
606 MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1, str->str.w, *pcchValueBuf );
608 else
610 len = lstrlenA( prop->u.pszVal );
611 if( str->str.a )
612 lstrcpynA(str->str.a, prop->u.pszVal, *pcchValueBuf );
614 if (len >= *pcchValueBuf)
615 ret = ERROR_MORE_DATA;
616 *pcchValueBuf = len;
618 break;
619 case VT_FILETIME:
620 if( pftValue )
621 *pftValue = prop->u.filetime;
622 break;
623 case VT_EMPTY:
624 break;
625 default:
626 FIXME("Unknown property variant type\n");
627 break;
629 msiobj_release( &si->hdr );
630 return ret;
633 LPWSTR msi_suminfo_dup_string( MSISUMMARYINFO *si, UINT uiProperty )
635 PROPVARIANT *prop;
637 if ( uiProperty >= MSI_MAX_PROPS )
638 return NULL;
639 prop = &si->property[uiProperty];
640 if( prop->vt != VT_LPSTR )
641 return NULL;
642 return strdupAtoW( prop->u.pszVal );
645 INT msi_suminfo_get_int32( MSISUMMARYINFO *si, UINT uiProperty )
647 PROPVARIANT *prop;
649 if ( uiProperty >= MSI_MAX_PROPS )
650 return -1;
651 prop = &si->property[uiProperty];
652 if( prop->vt != VT_I4 )
653 return -1;
654 return prop->u.lVal;
657 LPWSTR msi_get_suminfo_product( IStorage *stg )
659 MSISUMMARYINFO *si;
660 LPWSTR prod;
662 si = MSI_GetSummaryInformationW( stg, 0 );
663 if (!si)
665 ERR("no summary information!\n");
666 return NULL;
668 prod = msi_suminfo_dup_string( si, PID_REVNUMBER );
669 msiobj_release( &si->hdr );
670 return prod;
673 UINT WINAPI MsiSummaryInfoGetPropertyA(
674 MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
675 FILETIME *pftValue, LPSTR szValueBuf, LPDWORD pcchValueBuf)
677 awstring str;
679 TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
680 piValue, pftValue, szValueBuf, pcchValueBuf );
682 str.unicode = FALSE;
683 str.str.a = szValueBuf;
685 return get_prop( handle, uiProperty, puiDataType, piValue,
686 pftValue, &str, pcchValueBuf );
689 UINT WINAPI MsiSummaryInfoGetPropertyW(
690 MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
691 FILETIME *pftValue, LPWSTR szValueBuf, LPDWORD pcchValueBuf)
693 awstring str;
695 TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
696 piValue, pftValue, szValueBuf, pcchValueBuf );
698 str.unicode = TRUE;
699 str.str.w = szValueBuf;
701 return get_prop( handle, uiProperty, puiDataType, piValue,
702 pftValue, &str, pcchValueBuf );
705 static UINT set_prop( MSISUMMARYINFO *si, UINT uiProperty, UINT type,
706 INT iValue, FILETIME* pftValue, awcstring *str )
708 PROPVARIANT *prop;
709 UINT len;
711 TRACE("%p %u %u %i %p %p\n", si, uiProperty, type, iValue,
712 pftValue, str );
714 prop = &si->property[uiProperty];
716 if( prop->vt == VT_EMPTY )
718 if( !si->update_count )
719 return ERROR_FUNCTION_FAILED;
721 si->update_count--;
723 else if( prop->vt != type )
724 return ERROR_SUCCESS;
726 free_prop( prop );
727 prop->vt = type;
728 switch( type )
730 case VT_I4:
731 prop->u.lVal = iValue;
732 break;
733 case VT_I2:
734 prop->u.iVal = iValue;
735 break;
736 case VT_FILETIME:
737 prop->u.filetime = *pftValue;
738 break;
739 case VT_LPSTR:
740 if( str->unicode )
742 len = WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
743 NULL, 0, NULL, NULL );
744 prop->u.pszVal = msi_alloc( len );
745 WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
746 prop->u.pszVal, len, NULL, NULL );
748 else
750 len = lstrlenA( str->str.a ) + 1;
751 prop->u.pszVal = msi_alloc( len );
752 lstrcpyA( prop->u.pszVal, str->str.a );
754 break;
757 return ERROR_SUCCESS;
760 UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty,
761 UINT uiDataType, INT iValue, FILETIME* pftValue, LPCWSTR szValue )
763 awcstring str;
764 MSISUMMARYINFO *si;
765 UINT type, ret;
767 TRACE("%d %u %u %i %p %s\n", handle, uiProperty, uiDataType,
768 iValue, pftValue, debugstr_w(szValue) );
770 type = get_type( uiProperty );
771 if( type == VT_EMPTY || type != uiDataType )
772 return ERROR_DATATYPE_MISMATCH;
774 if( uiDataType == VT_LPSTR && !szValue )
775 return ERROR_INVALID_PARAMETER;
777 if( uiDataType == VT_FILETIME && !pftValue )
778 return ERROR_INVALID_PARAMETER;
780 si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
781 if( !si )
782 return ERROR_INVALID_HANDLE;
784 str.unicode = TRUE;
785 str.str.w = szValue;
786 ret = set_prop( si, uiProperty, type, iValue, pftValue, &str );
788 msiobj_release( &si->hdr );
789 return ret;
792 UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty,
793 UINT uiDataType, INT iValue, FILETIME* pftValue, LPCSTR szValue )
795 awcstring str;
796 MSISUMMARYINFO *si;
797 UINT type, ret;
799 TRACE("%d %u %u %i %p %s\n", handle, uiProperty, uiDataType,
800 iValue, pftValue, debugstr_a(szValue) );
802 type = get_type( uiProperty );
803 if( type == VT_EMPTY || type != uiDataType )
804 return ERROR_DATATYPE_MISMATCH;
806 if( uiDataType == VT_LPSTR && !szValue )
807 return ERROR_INVALID_PARAMETER;
809 if( uiDataType == VT_FILETIME && !pftValue )
810 return ERROR_INVALID_PARAMETER;
812 si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
813 if( !si )
814 return ERROR_INVALID_HANDLE;
816 str.unicode = FALSE;
817 str.str.a = szValue;
818 ret = set_prop( si, uiProperty, uiDataType, iValue, pftValue, &str );
820 msiobj_release( &si->hdr );
821 return ret;
824 static UINT suminfo_persist( MSISUMMARYINFO *si )
826 UINT ret = ERROR_FUNCTION_FAILED;
827 IStream *stm = NULL;
828 DWORD grfMode;
829 HRESULT r;
831 grfMode = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
832 r = IStorage_CreateStream( si->storage, szSumInfo, grfMode, 0, 0, &stm );
833 if( SUCCEEDED(r) )
835 ret = save_summary_info( si, stm );
836 IStream_Release( stm );
838 return ret;
841 static void parse_filetime( LPCWSTR str, FILETIME *ft )
843 SYSTEMTIME lt, utc;
844 const WCHAR *p = str;
845 WCHAR *end;
847 memset( &lt, 0, sizeof(lt) );
849 /* YYYY/MM/DD hh:mm:ss */
851 while (isspaceW( *p )) p++;
853 lt.wYear = strtolW( p, &end, 10 );
854 if (*end != '/') return;
855 p = end + 1;
857 lt.wMonth = strtolW( p, &end, 10 );
858 if (*end != '/') return;
859 p = end + 1;
861 lt.wDay = strtolW( p, &end, 10 );
862 if (*end != ' ') return;
863 p = end + 1;
865 while (isspaceW( *p )) p++;
867 lt.wHour = strtolW( p, &end, 10 );
868 if (*end != ':') return;
869 p = end + 1;
871 lt.wMinute = strtolW( p, &end, 10 );
872 if (*end != ':') return;
873 p = end + 1;
875 lt.wSecond = strtolW( p, &end, 10 );
877 TzSpecificLocalTimeToSystemTime( NULL, &lt, &utc );
878 SystemTimeToFileTime( &utc, ft );
881 static UINT parse_prop( LPCWSTR prop, LPCWSTR value, UINT *pid, INT *int_value,
882 FILETIME *ft_value, awcstring *str_value )
884 *pid = atoiW( prop );
885 switch (*pid)
887 case PID_CODEPAGE:
888 case PID_WORDCOUNT:
889 case PID_CHARCOUNT:
890 case PID_SECURITY:
891 case PID_PAGECOUNT:
892 *int_value = atoiW( value );
893 break;
895 case PID_LASTPRINTED:
896 case PID_CREATE_DTM:
897 case PID_LASTSAVE_DTM:
898 parse_filetime( value, ft_value );
899 break;
901 case PID_SUBJECT:
902 case PID_AUTHOR:
903 case PID_KEYWORDS:
904 case PID_COMMENTS:
905 case PID_TEMPLATE:
906 case PID_LASTAUTHOR:
907 case PID_REVNUMBER:
908 case PID_APPNAME:
909 case PID_TITLE:
910 str_value->str.w = value;
911 str_value->unicode = TRUE;
912 break;
914 default:
915 WARN("unhandled prop id %u\n", *pid);
916 return ERROR_FUNCTION_FAILED;
919 return ERROR_SUCCESS;
922 UINT msi_add_suminfo( MSIDATABASE *db, LPWSTR **records, int num_records, int num_columns )
924 UINT r = ERROR_FUNCTION_FAILED;
925 DWORD i, j;
926 MSISUMMARYINFO *si;
928 si = MSI_GetSummaryInformationW( db->storage, num_records * (num_columns / 2) );
929 if (!si)
931 ERR("no summary information!\n");
932 return ERROR_FUNCTION_FAILED;
935 for (i = 0; i < num_records; i++)
937 for (j = 0; j < num_columns; j += 2)
939 UINT pid;
940 INT int_value = 0;
941 FILETIME ft_value;
942 awcstring str_value;
944 r = parse_prop( records[i][j], records[i][j + 1], &pid, &int_value, &ft_value, &str_value );
945 if (r != ERROR_SUCCESS)
946 goto end;
948 r = set_prop( si, pid, get_type(pid), int_value, &ft_value, &str_value );
949 if (r != ERROR_SUCCESS)
950 goto end;
954 end:
955 if (r == ERROR_SUCCESS)
956 r = suminfo_persist( si );
958 msiobj_release( &si->hdr );
959 return r;
962 UINT WINAPI MsiSummaryInfoPersist( MSIHANDLE handle )
964 MSISUMMARYINFO *si;
965 UINT ret;
967 TRACE("%d\n", handle );
969 si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
970 if( !si )
971 return ERROR_INVALID_HANDLE;
973 ret = suminfo_persist( si );
975 msiobj_release( &si->hdr );
976 return ret;
979 UINT WINAPI MsiCreateTransformSummaryInfoA( MSIHANDLE db, MSIHANDLE db_ref, LPCSTR transform, int error, int validation )
981 UINT r;
982 WCHAR *transformW = NULL;
984 TRACE("%u, %u, %s, %d, %d\n", db, db_ref, debugstr_a(transform), error, validation);
986 if (transform && !(transformW = strdupAtoW( transform )))
987 return ERROR_OUTOFMEMORY;
989 r = MsiCreateTransformSummaryInfoW( db, db_ref, transformW, error, validation );
990 msi_free( transformW );
991 return r;
994 UINT WINAPI MsiCreateTransformSummaryInfoW( MSIHANDLE db, MSIHANDLE db_ref, LPCWSTR transform, int error, int validation )
996 FIXME("%u, %u, %s, %d, %d\n", db, db_ref, debugstr_w(transform), error, validation);
997 return ERROR_FUNCTION_FAILED;