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