git.oblomov.eu Git - wine/blob - dlls/msi/suminfo.c

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