a02f949cb2454b172558f058b253e1c47f5a6a16
[reactos.git] / reactos / dll / win32 / 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 memset( si->property, 0, sizeof si->property );
447 si->update_count = uiUpdateCount;
448 IStorage_AddRef( stg );
449 si->storage = stg;
450
451 /* read the stream... if we fail, we'll start with an empty property set */
452 grfMode = STGM_READ | STGM_SHARE_EXCLUSIVE;
453 r = IStorage_OpenStream( si->storage, szSumInfo, 0, grfMode, 0, &stm );
454 if( SUCCEEDED(r) )
455 {
456 load_summary_info( si, stm );
457 IStream_Release( stm );
458 }
459
460 return si;
461 }
462
463 UINT WINAPI MsiGetSummaryInformationW( MSIHANDLE hDatabase,
464 LPCWSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle )
465 {
466 MSISUMMARYINFO *si;
467 MSIDATABASE *db;
468 UINT ret = ERROR_FUNCTION_FAILED;
469
470 TRACE("%d %s %d %p\n", hDatabase, debugstr_w(szDatabase),
471 uiUpdateCount, pHandle);
472
473 if( !pHandle )
474 return ERROR_INVALID_PARAMETER;
475
476 if( szDatabase )
477 {
478 ret = MSI_OpenDatabaseW( szDatabase, NULL, &db );
479 if( ret != ERROR_SUCCESS )
480 return ret;
481 }
482 else
483 {
484 db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
485 if( !db )
486 {
487 HRESULT hr;
488 IWineMsiRemoteDatabase *remote_database;
489
490 remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hDatabase );
491 if ( !remote_database )
492 return ERROR_INVALID_HANDLE;
493
494 hr = IWineMsiRemoteDatabase_GetSummaryInformation( remote_database,
495 uiUpdateCount, pHandle );
496 IWineMsiRemoteDatabase_Release( remote_database );
497
498 if (FAILED(hr))
499 {
500 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
501 return HRESULT_CODE(hr);
502
503 return ERROR_FUNCTION_FAILED;
504 }
505
506 return ERROR_SUCCESS;
507 }
508 }
509
510 si = MSI_GetSummaryInformationW( db->storage, uiUpdateCount );
511 if (si)
512 {
513 *pHandle = alloc_msihandle( &si->hdr );
514 if( *pHandle )
515 ret = ERROR_SUCCESS;
516 else
517 ret = ERROR_NOT_ENOUGH_MEMORY;
518 msiobj_release( &si->hdr );
519 }
520
521 if( db )
522 msiobj_release( &db->hdr );
523
524 return ret;
525 }
526
527 UINT WINAPI MsiGetSummaryInformationA(MSIHANDLE hDatabase,
528 LPCSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle)
529 {
530 LPWSTR szwDatabase = NULL;
531 UINT ret;
532
533 TRACE("%d %s %d %p\n", hDatabase, debugstr_a(szDatabase),
534 uiUpdateCount, pHandle);
535
536 if( szDatabase )
537 {
538 szwDatabase = strdupAtoW( szDatabase );
539 if( !szwDatabase )
540 return ERROR_FUNCTION_FAILED;
541 }
542
543 ret = MsiGetSummaryInformationW(hDatabase, szwDatabase, uiUpdateCount, pHandle);
544
545 msi_free( szwDatabase );
546
547 return ret;
548 }
549
550 UINT WINAPI MsiSummaryInfoGetPropertyCount(MSIHANDLE hSummaryInfo, PUINT pCount)
551 {
552 MSISUMMARYINFO *si;
553
554 TRACE("%d %p\n", hSummaryInfo, pCount);
555
556 si = msihandle2msiinfo( hSummaryInfo, MSIHANDLETYPE_SUMMARYINFO );
557 if( !si )
558 return ERROR_INVALID_HANDLE;
559
560 if( pCount )
561 *pCount = get_property_count( si->property );
562 msiobj_release( &si->hdr );
563
564 return ERROR_SUCCESS;
565 }
566
567 static UINT get_prop( MSIHANDLE handle, UINT uiProperty, UINT *puiDataType,
568 INT *piValue, FILETIME *pftValue, awstring *str, DWORD *pcchValueBuf)
569 {
570 MSISUMMARYINFO *si;
571 PROPVARIANT *prop;
572 UINT ret = ERROR_SUCCESS;
573
574 TRACE("%d %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
575 piValue, pftValue, str, pcchValueBuf);
576
577 if ( uiProperty >= MSI_MAX_PROPS )
578 {
579 if (puiDataType) *puiDataType = VT_EMPTY;
580 return ERROR_UNKNOWN_PROPERTY;
581 }
582
583 si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
584 if( !si )
585 return ERROR_INVALID_HANDLE;
586
587 prop = &si->property[uiProperty];
588
589 if( puiDataType )
590 *puiDataType = prop->vt;
591
592 switch( prop->vt )
593 {
594 case VT_I2:
595 if( piValue )
596 *piValue = prop->u.iVal;
597 break;
598 case VT_I4:
599 if( piValue )
600 *piValue = prop->u.lVal;
601 break;
602 case VT_LPSTR:
603 if( pcchValueBuf )
604 {
605 DWORD len = 0;
606
607 if( str->unicode )
608 {
609 len = MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1,
610 str->str.w, *pcchValueBuf );
611 len--;
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 }