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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #define PRSPEC_PROPID (1)
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winreg.h"
  31 #include "winnls.h"
  32 #include "shlwapi.h"
  33 #include "wine/debug.h"
  34 #include "msi.h"
  35 #include "msiquery.h"
  36 #include "msidefs.h"
  37 #include "msipriv.h"
  38 #include "objidl.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  41
  42 #include "pshpack1.h"
  43
  44 typedef struct {
  45     WORD wByteOrder;
  46     WORD wFormat;
  47     DWORD dwOSVer;
  48     CLSID clsID;
  49     DWORD reserved;
  50 } PROPERTYSETHEADER;
  51
  52 typedef struct {
  53     FMTID fmtid;
  54     DWORD dwOffset;
  55 } FORMATIDOFFSET;
  56
  57 typedef struct {
  58     DWORD cbSection;
  59     DWORD cProperties;
  60 } PROPERTYSECTIONHEADER;
  61
  62 typedef struct {
  63     DWORD propid;
  64     DWORD dwOffset;
  65 } PROPERTYIDOFFSET;
  66
  67 typedef struct {
  68     DWORD type;
  69     union {
  70         INT i4;
  71         SHORT i2;
  72         FILETIME ft;
  73         struct {
  74             DWORD len;
  75             BYTE str[1];
  76         } str;
  77     } u;
  78 } PROPERTY_DATA;
  79
  80 #include "poppack.h"
  81
  82 #define SECT_HDR_SIZE (sizeof(PROPERTYSECTIONHEADER))
  83
  84 static const WCHAR szSumInfo[] = { 5 ,'S','u','m','m','a','r','y',
  85                        'I','n','f','o','r','m','a','t','i','o','n',0 };
  86
  87 static void free_prop( PROPVARIANT *prop )
  88 {
  89     if (prop->vt == VT_LPSTR )
  90         msi_free( prop->u.pszVal );
  91     prop->vt = VT_EMPTY;
  92 }
  93
  94 static void MSI_CloseSummaryInfo( MSIOBJECTHDR *arg )
  95 {
  96     MSISUMMARYINFO *si = (MSISUMMARYINFO *) arg;
  97     DWORD i;
  98
  99     for( i = 0; i < MSI_MAX_PROPS; i++ )
 100         free_prop( &si->property[i] );
 101     msiobj_release( &si->db->hdr );
 102 }
 103
 104 static UINT get_type( UINT uiProperty )
 105 {
 106     switch( uiProperty )
 107     {
 108     case PID_CODEPAGE:
 109          return VT_I2;
 110
 111     case PID_SUBJECT:
 112     case PID_AUTHOR:
 113     case PID_KEYWORDS:
 114     case PID_COMMENTS:
 115     case PID_TEMPLATE:
 116     case PID_LASTAUTHOR:
 117     case PID_REVNUMBER:
 118     case PID_APPNAME:
 119     case PID_TITLE:
 120          return VT_LPSTR;
 121
 122     case PID_LASTPRINTED:
 123     case PID_CREATE_DTM:
 124     case PID_LASTSAVE_DTM:
 125          return VT_FILETIME;
 126
 127     case PID_WORDCOUNT:
 128     case PID_CHARCOUNT:
 129     case PID_SECURITY:
 130     case PID_PAGECOUNT:
 131          return VT_I4;
 132     }
 133     return VT_EMPTY;
 134 }
 135
 136 static UINT get_property_count( PROPVARIANT *property )
 137 {
 138     UINT i, n = 0;
 139
 140     if( !property )
 141         return n;
 142     for( i = 0; i < MSI_MAX_PROPS; i++ )
 143         if( property[i].vt != VT_EMPTY )
 144             n++;
 145     return n;
 146 }
 147
 148 /* FIXME: doesn't deal with endian conversion */
 149 static void read_properties_from_data( PROPVARIANT *prop, LPBYTE data, DWORD sz )
 150 {
 151     UINT type;
 152     DWORD i;
 153     int size;
 154     PROPERTY_DATA *propdata;
 155     PROPVARIANT *property;
 156     PROPERTYIDOFFSET *idofs;
 157     PROPERTYSECTIONHEADER *section_hdr;
 158
 159     section_hdr = (PROPERTYSECTIONHEADER*) &data[0];
 160     idofs = (PROPERTYIDOFFSET*) &data[SECT_HDR_SIZE];
 161
 162     /* now set all the properties */
 163     for( i = 0; i < section_hdr->cProperties; i++ )
 164     {
 165         type = get_type( idofs[i].propid );
 166         if( type == VT_EMPTY )
 167         {
 168             ERR("propid %ld has unknown type\n", idofs[i].propid);
 169             break;
 170         }
 171
 172         propdata = (PROPERTY_DATA*) &data[ idofs[i].dwOffset ];
 173
 174         /* check the type is the same as we expect */
 175         if( type != propdata->type )
 176         {
 177             ERR("wrong type %d != %ld\n", type, propdata->type);
 178             break;
 179         }
 180
 181         /* check we don't run off the end of the data */
 182         size = sz - idofs[i].dwOffset - sizeof(DWORD);
 183         if( sizeof(DWORD) > size ||
 184             ( type == VT_FILETIME && sizeof(FILETIME) > size ) ||
 185             ( type == VT_LPSTR && (propdata->u.str.len + sizeof(DWORD)) > size ) )
 186         {
 187             ERR("not enough data\n");
 188             break;
 189         }
 190
 191         if( idofs[i].propid >= MSI_MAX_PROPS )
 192         {
 193             ERR("Unknown property ID %ld\n", idofs[i].propid );
 194             break;
 195         }
 196
 197         property = &prop[ idofs[i].propid ];
 198         property->vt = type;
 199
 200         if( type == VT_LPSTR )
 201         {
 202             LPSTR str = msi_alloc( propdata->u.str.len );
 203             memcpy( str, propdata->u.str.str, propdata->u.str.len );
 204             str[ propdata->u.str.len - 1 ] = 0;
 205             property->u.pszVal = str;
 206         }
 207         else if( type == VT_FILETIME )
 208             property->u.filetime = propdata->u.ft;
 209         else if( type == VT_I2 )
 210             property->u.iVal = propdata->u.i2;
 211         else if( type == VT_I4 )
 212             property->u.lVal = propdata->u.i4;
 213     }
 214 }
 215
 216 static UINT load_summary_info( MSISUMMARYINFO *si, IStream *stm )
 217 {
 218     UINT ret = ERROR_FUNCTION_FAILED;
 219     PROPERTYSETHEADER set_hdr;
 220     FORMATIDOFFSET format_hdr;
 221     PROPERTYSECTIONHEADER section_hdr;
 222     LPBYTE data = NULL;
 223     LARGE_INTEGER ofs;
 224     ULONG count, sz;
 225     HRESULT r;
 226
 227     TRACE("%p %p\n", si, stm);
 228
 229     /* read the header */
 230     sz = sizeof set_hdr;
 231     r = IStream_Read( stm, &set_hdr, sz, &count );
 232     if( FAILED(r) || count != sz )
 233         return ret;
 234
 235     if( set_hdr.wByteOrder != 0xfffe )
 236     {
 237         ERR("property set not big-endian %04X\n", set_hdr.wByteOrder);
 238         return ret;
 239     }
 240
 241     sz = sizeof format_hdr;
 242     r = IStream_Read( stm, &format_hdr, sz, &count );
 243     if( FAILED(r) || count != sz )
 244         return ret;
 245
 246     /* check the format id is correct */
 247     if( !IsEqualGUID( &FMTID_SummaryInformation, &format_hdr.fmtid ) )
 248         return ret;
 249
 250     /* seek to the location of the section */
 251     ofs.QuadPart = format_hdr.dwOffset;
 252     r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, NULL );
 253     if( FAILED(r) )
 254         return ret;
 255
 256     /* read the section itself */
 257     sz = SECT_HDR_SIZE;
 258     r = IStream_Read( stm, &section_hdr, sz, &count );
 259     if( FAILED(r) || count != sz )
 260         return ret;
 261
 262     if( section_hdr.cProperties > MSI_MAX_PROPS )
 263     {
 264         ERR("too many properties %ld\n", section_hdr.cProperties);
 265         return ret;
 266     }
 267
 268     data = msi_alloc( section_hdr.cbSection);
 269     if( !data )
 270         return ret;
 271
 272     memcpy( data, &section_hdr, SECT_HDR_SIZE );
 273
 274     /* read all the data in one go */
 275     sz = section_hdr.cbSection - SECT_HDR_SIZE;
 276     r = IStream_Read( stm, &data[ SECT_HDR_SIZE ], sz, &count );
 277     if( SUCCEEDED(r) && count == sz )
 278         read_properties_from_data( si->property, data, sz + SECT_HDR_SIZE );
 279     else
 280         ERR("failed to read properties %ld %ld\n", count, sz);
 281
 282     msi_free( data );
 283     return ret;
 284 }
 285
 286 static DWORD write_dword( LPBYTE data, DWORD ofs, DWORD val )
 287 {
 288     if( data )
 289     {
 290         data[ofs++] = val&0xff;
 291         data[ofs++] = (val>>8)&0xff;
 292         data[ofs++] = (val>>16)&0xff;
 293         data[ofs++] = (val>>24)&0xff;
 294     }
 295     return 4;
 296 }
 297
 298 static DWORD write_filetime( LPBYTE data, DWORD ofs, LPFILETIME ft )
 299 {
 300     write_dword( data, ofs, ft->dwLowDateTime );
 301     write_dword( data, ofs + 4, ft->dwHighDateTime );
 302     return 8;
 303 }
 304
 305 static DWORD write_string( LPBYTE data, DWORD ofs, LPCSTR str )
 306 {
 307     DWORD len = lstrlenA( str ) + 1;
 308     write_dword( data, ofs, len );
 309     if( data )
 310         memcpy( &data[ofs + 4], str, len );
 311     return (7 + len) & ~3;
 312 }
 313
 314 static UINT write_property_to_data( PROPVARIANT *prop, LPBYTE data )
 315 {
 316     DWORD sz = 0;
 317
 318     if( prop->vt == VT_EMPTY )
 319         return sz;
 320
 321     /* add the type */
 322     sz += write_dword( data, sz, prop->vt );
 323     switch( prop->vt )
 324     {
 325     case VT_I2:
 326         sz += write_dword( data, sz, prop->u.iVal );
 327         break;
 328     case VT_I4:
 329         sz += write_dword( data, sz, prop->u.lVal );
 330         break;
 331     case VT_FILETIME:
 332         sz += write_filetime( data, sz, &prop->u.filetime );
 333         break;
 334     case VT_LPSTR:
 335         sz += write_string( data, sz, prop->u.pszVal );
 336         break;
 337     }
 338     return sz;
 339 }
 340
 341 static UINT save_summary_info( MSISUMMARYINFO * si, IStream *stm )
 342 {
 343     UINT ret = ERROR_FUNCTION_FAILED;
 344     PROPERTYSETHEADER set_hdr;
 345     FORMATIDOFFSET format_hdr;
 346     PROPERTYSECTIONHEADER section_hdr;
 347     PROPERTYIDOFFSET idofs[MSI_MAX_PROPS];
 348     LPBYTE data = NULL;
 349     ULONG count, sz;
 350     HRESULT r;
 351     int i, n;
 352
 353     /* write the header */
 354     sz = sizeof set_hdr;
 355     memset( &set_hdr, 0, sz );
 356     set_hdr.wByteOrder = 0xfffe;
 357     set_hdr.wFormat = 0;
 358     set_hdr.dwOSVer = 0x00020005; /* build 5, platform id 2 */
 359     /* set_hdr.clsID is {00000000-0000-0000-0000-000000000000} */
 360     set_hdr.reserved = 1;
 361     r = IStream_Write( stm, &set_hdr, sz, &count );
 362     if( FAILED(r) || count != sz )
 363         return ret;
 364
 365     /* write the format header */
 366     sz = sizeof format_hdr;
 367     memcpy( &format_hdr.fmtid, &FMTID_SummaryInformation, sizeof (FMTID) );
 368     format_hdr.dwOffset = sizeof format_hdr + sizeof set_hdr;
 369     r = IStream_Write( stm, &format_hdr, sz, &count );
 370     if( FAILED(r) || count != sz )
 371         return ret;
 372
 373     /* add up how much space the data will take and calculate the offsets */
 374     section_hdr.cbSection = sizeof section_hdr;
 375     section_hdr.cbSection += (get_property_count( si->property ) * sizeof idofs[0]);
 376     section_hdr.cProperties = 0;
 377     n = 0;
 378     for( i = 0; i < MSI_MAX_PROPS; i++ )
 379     {
 380         sz = write_property_to_data( &si->property[i], NULL );
 381         if( !sz )
 382             continue;
 383         idofs[ section_hdr.cProperties ].propid = i;
 384         idofs[ section_hdr.cProperties ].dwOffset = section_hdr.cbSection;
 385         section_hdr.cProperties++;
 386         section_hdr.cbSection += sz;
 387     }
 388
 389     data = msi_alloc_zero( section_hdr.cbSection );
 390
 391     sz = 0;
 392     memcpy( &data[sz], &section_hdr, sizeof section_hdr );
 393     sz += sizeof section_hdr;
 394
 395     memcpy( &data[sz], idofs, section_hdr.cProperties * sizeof idofs[0] );
 396     sz += section_hdr.cProperties * sizeof idofs[0];
 397
 398     /* write out the data */
 399     for( i = 0; i < MSI_MAX_PROPS; i++ )
 400         sz += write_property_to_data( &si->property[i], &data[sz] );
 401
 402     r = IStream_Write( stm, data, sz, &count );
 403     msi_free( data );
 404     if( FAILED(r) || count != sz )
 405         return ret;
 406
 407     return ERROR_SUCCESS;
 408 }
 409
 410 MSISUMMARYINFO *MSI_GetSummaryInformationW( MSIDATABASE *db, UINT uiUpdateCount )
 411 {
 412     IStream *stm = NULL;
 413     MSISUMMARYINFO *si;
 414     DWORD grfMode;
 415     HRESULT r;
 416
 417     TRACE("%p %d\n", db, uiUpdateCount );
 418
 419     si = alloc_msiobject( MSIHANDLETYPE_SUMMARYINFO,
 420                   sizeof (MSISUMMARYINFO), MSI_CloseSummaryInfo );
 421     if( !si )
 422         return si;
 423
 424     msiobj_addref( &db->hdr );
 425     si->db = db;
 426     memset( &si->property, 0, sizeof si->property );
 427     si->update_count = uiUpdateCount;
 428
 429     /* read the stream... if we fail, we'll start with an empty property set */
 430     grfMode = STGM_READ | STGM_SHARE_EXCLUSIVE;
 431     r = IStorage_OpenStream( si->db->storage, szSumInfo, 0, grfMode, 0, &stm );
 432     if( SUCCEEDED(r) )
 433     {
 434         load_summary_info( si, stm );
 435         IStream_Release( stm );
 436     }
 437
 438     return si;
 439 }
 440
 441 UINT WINAPI MsiGetSummaryInformationW( MSIHANDLE hDatabase,
 442               LPCWSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle )
 443 {
 444     MSISUMMARYINFO *si;
 445     MSIDATABASE *db;
 446     UINT ret = ERROR_FUNCTION_FAILED;
 447
 448     TRACE("%ld %s %d %p\n", hDatabase, debugstr_w(szDatabase),
 449            uiUpdateCount, pHandle);
 450
 451     if( !pHandle )
 452         return ERROR_INVALID_PARAMETER;
 453
 454     if( szDatabase )
 455     {
 456         ret = MSI_OpenDatabaseW( szDatabase, NULL, &db );
 457         if( ret != ERROR_SUCCESS )
 458             return ret;
 459     }
 460     else
 461     {
 462         db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
 463         if( !db )
 464             return ERROR_INVALID_PARAMETER;
 465     }
 466
 467     si = MSI_GetSummaryInformationW( db, uiUpdateCount );
 468     if (si)
 469     {
 470         *pHandle = alloc_msihandle( &si->hdr );
 471         if( *pHandle )
 472             ret = ERROR_SUCCESS;
 473         msiobj_release( &si->hdr );
 474     }
 475
 476     if( db )
 477         msiobj_release( &db->hdr );
 478
 479     return ret;
 480 }
 481
 482 UINT WINAPI MsiGetSummaryInformationA(MSIHANDLE hDatabase,
 483               LPCSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle)
 484 {
 485     LPWSTR szwDatabase = NULL;
 486     UINT ret;
 487
 488     TRACE("%ld %s %d %p\n", hDatabase, debugstr_a(szDatabase),
 489           uiUpdateCount, pHandle);
 490
 491     if( szDatabase )
 492     {
 493         szwDatabase = strdupAtoW( szDatabase );
 494         if( !szwDatabase )
 495             return ERROR_FUNCTION_FAILED;
 496     }
 497
 498     ret = MsiGetSummaryInformationW(hDatabase, szwDatabase, uiUpdateCount, pHandle);
 499
 500     msi_free( szwDatabase );
 501
 502     return ret;
 503 }
 504
 505 UINT WINAPI MsiSummaryInfoGetPropertyCount(MSIHANDLE hSummaryInfo, UINT *pCount)
 506 {
 507     MSISUMMARYINFO *si;
 508
 509     TRACE("%ld %p\n",hSummaryInfo, pCount);
 510
 511     si = msihandle2msiinfo( hSummaryInfo, MSIHANDLETYPE_SUMMARYINFO );
 512     if( !si )
 513         return ERROR_INVALID_HANDLE;
 514
 515     if( pCount )
 516         *pCount = get_property_count( si->property );
 517     msiobj_release( &si->hdr );
 518
 519     return ERROR_SUCCESS;
 520 }
 521
 522 static UINT get_prop( MSIHANDLE handle, UINT uiProperty, UINT *puiDataType,
 523           INT *piValue, FILETIME *pftValue, awstring *str, DWORD *pcchValueBuf)
 524 {
 525     MSISUMMARYINFO *si;
 526     PROPVARIANT *prop;
 527     UINT ret = ERROR_SUCCESS;
 528
 529     TRACE("%ld %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
 530           piValue, pftValue, str, pcchValueBuf);
 531
 532     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
 533     if( !si )
 534         return ERROR_INVALID_HANDLE;
 535
 536     if ( uiProperty >= MSI_MAX_PROPS )
 537     {
 538         *puiDataType = VT_EMPTY;
 539         return ret;
 540     }
 541
 542     prop = &si->property[uiProperty];
 543
 544     if( puiDataType )
 545         *puiDataType = prop->vt;
 546
 547     switch( prop->vt )
 548     {
 549     case VT_I2:
 550         if( piValue )
 551             *piValue = prop->u.iVal;
 552         break;
 553     case VT_I4:
 554         if( piValue )
 555             *piValue = prop->u.lVal;
 556         break;
 557     case VT_LPSTR:
 558         if( pcchValueBuf )
 559         {
 560             DWORD len = 0;
 561
 562             if( str->unicode )
 563             {
 564                 len = MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1,
 565                                            str->str.w, *pcchValueBuf );
 566                 len--;
 567             }
 568             else
 569             {
 570                 len = lstrlenA( prop->u.pszVal );
 571                 if( str->str.a )
 572                     lstrcpynA(str->str.a, prop->u.pszVal, *pcchValueBuf );
 573             }
 574             if (len >= *pcchValueBuf)
 575                 ret = ERROR_MORE_DATA;
 576             *pcchValueBuf = len;
 577         }
 578         break;
 579     case VT_FILETIME:
 580         if( pftValue )
 581             memcpy(pftValue, &prop->u.filetime, sizeof (FILETIME) );
 582         break;
 583     case VT_EMPTY:
 584         break;
 585     default:
 586         FIXME("Unknown property variant type\n");
 587         break;
 588     }
 589     msiobj_release( &si->hdr );
 590     return ret;
 591 }
 592
 593 LPWSTR msi_suminfo_dup_string( MSISUMMARYINFO *si, UINT uiProperty )
 594 {
 595     PROPVARIANT *prop;
 596
 597     if ( uiProperty >= MSI_MAX_PROPS )
 598         return NULL;
 599     prop = &si->property[uiProperty];
 600     if( prop->vt != VT_LPSTR )
 601         return NULL;
 602     return strdupAtoW( prop->u.pszVal );
 603 }
 604
 605 UINT WINAPI MsiSummaryInfoGetPropertyA(
 606       MSIHANDLE handle, UINT uiProperty, UINT *puiDataType, INT *piValue,
 607       FILETIME *pftValue, LPSTR szValueBuf, DWORD *pcchValueBuf)
 608 {
 609     awstring str;
 610
 611     TRACE("%ld %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
 612           piValue, pftValue, szValueBuf, pcchValueBuf );
 613
 614     str.unicode = FALSE;
 615     str.str.a = szValueBuf;
 616
 617     return get_prop( handle, uiProperty, puiDataType, piValue,
 618                      pftValue, &str, pcchValueBuf );
 619 }
 620
 621 UINT WINAPI MsiSummaryInfoGetPropertyW(
 622       MSIHANDLE handle, UINT uiProperty, UINT *puiDataType, INT *piValue,
 623       FILETIME *pftValue, LPWSTR szValueBuf, DWORD *pcchValueBuf)
 624 {
 625     awstring str;
 626
 627     TRACE("%ld %d %p %p %p %p %p\n", handle, uiProperty, puiDataType,
 628           piValue, pftValue, szValueBuf, pcchValueBuf );
 629
 630     str.unicode = TRUE;
 631     str.str.w = szValueBuf;
 632
 633     return get_prop( handle, uiProperty, puiDataType, piValue,
 634                      pftValue, &str, pcchValueBuf );
 635 }
 636
 637 static UINT set_prop( MSIHANDLE handle, UINT uiProperty, UINT uiDataType,
 638                INT iValue, FILETIME* pftValue, awcstring *str )
 639 {
 640     MSISUMMARYINFO *si;
 641     PROPVARIANT *prop;
 642     UINT type, len, ret = ERROR_SUCCESS;
 643
 644     TRACE("%ld %u %u %i %p %p\n", handle, uiProperty, uiDataType,
 645           iValue, pftValue, str );
 646
 647     type = get_type( uiProperty );
 648     if( type == VT_EMPTY || type != uiDataType )
 649         return ERROR_DATATYPE_MISMATCH;
 650
 651     if( uiDataType == VT_LPSTR && !str->str.w )
 652         return ERROR_INVALID_PARAMETER;
 653
 654     if( uiDataType == VT_FILETIME && !pftValue )
 655         return ERROR_INVALID_PARAMETER;
 656
 657     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
 658     if( !si )
 659         return ERROR_INVALID_HANDLE;
 660
 661     prop = &si->property[uiProperty];
 662
 663     if( prop->vt == VT_EMPTY )
 664     {
 665         if( !si->update_count )
 666         {
 667             ret = ERROR_FUNCTION_FAILED;
 668             goto end;
 669         }
 670         si->update_count--;
 671     }
 672     else if( prop->vt != type )
 673         goto end;
 674
 675     free_prop( prop );
 676     prop->vt = type;
 677     switch( type )
 678     {
 679     case VT_I4:
 680         prop->u.lVal = iValue;
 681         break;
 682     case VT_I2:
 683         prop->u.iVal = iValue;
 684         break;
 685     case VT_FILETIME:
 686         memcpy( &prop->u.filetime, pftValue, sizeof prop->u.filetime );
 687         break;
 688     case VT_LPSTR:
 689         if( str->unicode )
 690         {
 691             len = WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
 692                                        NULL, 0, NULL, NULL );
 693             prop->u.pszVal = msi_alloc( len );
 694             WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
 695                                  prop->u.pszVal, len, NULL, NULL );
 696         }
 697         else
 698         {
 699             len = lstrlenA( str->str.a ) + 1;
 700             prop->u.pszVal = msi_alloc( len );
 701             lstrcpyA( prop->u.pszVal, str->str.a );
 702         }
 703         break;
 704     }
 705
 706 end:
 707     msiobj_release( &si->hdr );
 708     return ret;
 709 }
 710
 711 UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty,
 712                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCWSTR szValue )
 713 {
 714     awcstring str;
 715
 716     TRACE("%ld %u %u %i %p %s\n", handle, uiProperty, uiDataType,
 717           iValue, pftValue, debugstr_w(szValue) );
 718
 719     str.unicode = TRUE;
 720     str.str.w = szValue;
 721     return set_prop( handle, uiProperty, uiDataType, iValue, pftValue, &str );
 722 }
 723
 724 UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty,
 725                UINT uiDataType, INT iValue, FILETIME* pftValue, LPCSTR szValue )
 726 {
 727     awcstring str;
 728
 729     TRACE("%ld %u %u %i %p %s\n", handle, uiProperty, uiDataType,
 730           iValue, pftValue, debugstr_a(szValue) );
 731
 732     str.unicode = FALSE;
 733     str.str.a = szValue;
 734     return set_prop( handle, uiProperty, uiDataType, iValue, pftValue, &str );
 735 }
 736
 737 UINT WINAPI MsiSummaryInfoPersist( MSIHANDLE handle )
 738 {
 739     IStream *stm = NULL;
 740     MSISUMMARYINFO *si;
 741     DWORD grfMode;
 742     HRESULT r;
 743     UINT ret = ERROR_FUNCTION_FAILED;
 744
 745     TRACE("%ld\n", handle );
 746
 747     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
 748     if( !si )
 749         return ERROR_INVALID_HANDLE;
 750
 751     grfMode = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
 752     r = IStorage_CreateStream( si->db->storage, szSumInfo, grfMode, 0, 0, &stm );
 753     if( SUCCEEDED(r) )
 754     {
 755         ret = save_summary_info( si, stm );
 756         IStream_Release( stm );
 757     }
 758     msiobj_release( &si->hdr );
 759
 760     return ret;
 761 }