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 "stdio.h"
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winreg.h"
  30 #include "winnls.h"
  31 #include "shlwapi.h"
  32 #include "wine/debug.h"
  33 #include "wine/unicode.h"
  34 #include "msi.h"
  35 #include "msiquery.h"
  36 #include "msidefs.h"
  37 #include "msipriv.h"
  38 #include "objidl.h"
  39 #include "propvarutil.h"
  40 #include "msiserver.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  43
  44 #include "pshpack1.h"
  45
  46 typedef struct {
  47     WORD wByteOrder;
  48     WORD wFormat;
  49     DWORD dwOSVer;
  50     CLSID clsID;
  51     DWORD reserved;
  52 } PROPERTYSETHEADER;
  53
  54 typedef struct {
  55     FMTID fmtid;
  56     DWORD dwOffset;
  57 } FORMATIDOFFSET;
  58
  59 typedef struct {
  60     DWORD cbSection;
  61     DWORD cProperties;
  62 } PROPERTYSECTIONHEADER;
  63
  64 typedef struct {
  65     DWORD propid;
  66     DWORD dwOffset;
  67 } PROPERTYIDOFFSET;
  68
  69 typedef struct {
  70     DWORD type;
  71     union {
  72         INT i4;
  73         SHORT i2;
  74         FILETIME ft;
  75         struct {
  76             DWORD len;
  77             BYTE str[1];
  78         } str;
  79     } u;
  80 } PROPERTY_DATA;
  81
  82 #include "poppack.h"
  83
  84 static HRESULT (WINAPI *pPropVariantChangeType)
  85     (PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
  86      PROPVAR_CHANGE_FLAGS flags, VARTYPE vt);
  87
  88 #define SECT_HDR_SIZE (sizeof(PROPERTYSECTIONHEADER))
  89
  90 static void free_prop( PROPVARIANT *prop )
  91 {
  92     if (prop->vt == VT_LPSTR )
  93         msi_free( prop->u.pszVal );
  94     prop->vt = VT_EMPTY;
  95 }
  96
  97 static void MSI_CloseSummaryInfo( MSIOBJECTHDR *arg )
  98 {
  99     MSISUMMARYINFO *si = (MSISUMMARYINFO *) arg;
 100     DWORD i;
 101
 102     for( i = 0; i < MSI_MAX_PROPS; i++ )
 103         free_prop( &si->property[i] );
 104     IStorage_Release( si->storage );
 105 }
 106
 107 #ifdef __REACTOS__
 108 #define PID_DICTIONARY_MSI 0
 109 #define PID_CODEPAGE_MSI 1
 110 #define PID_SECURITY_MSI 19
 111 #endif
 112
 113 static UINT get_type( UINT uiProperty )
 114 {
 115     switch( uiProperty )
 116     {
 117 #ifdef __REACTOS__
 118     case PID_CODEPAGE_MSI:
 119 #else
 120     case PID_CODEPAGE:
 121 #endif
 122          return VT_I2;
 123
 124     case PID_SUBJECT:
 125     case PID_AUTHOR:
 126     case PID_KEYWORDS:
 127     case PID_COMMENTS:
 128     case PID_TEMPLATE:
 129     case PID_LASTAUTHOR:
 130     case PID_REVNUMBER:
 131     case PID_APPNAME:
 132     case PID_TITLE:
 133          return VT_LPSTR;
 134
 135     case PID_LASTPRINTED:
 136     case PID_CREATE_DTM:
 137     case PID_LASTSAVE_DTM:
 138          return VT_FILETIME;
 139
 140     case PID_WORDCOUNT:
 141     case PID_CHARCOUNT:
 142 #ifdef __REACTOS__
 143     case PID_SECURITY_MSI:
 144 #else
 145     case PID_SECURITY:
 146 #endif
 147     case PID_PAGECOUNT:
 148          return VT_I4;
 149     }
 150     return VT_EMPTY;
 151 }
 152
 153 static UINT get_property_count( const PROPVARIANT *property )
 154 {
 155     UINT i, n = 0;
 156
 157     if( !property )
 158         return n;
 159     for( i = 0; i < MSI_MAX_PROPS; i++ )
 160         if( property[i].vt != VT_EMPTY )
 161             n++;
 162     return n;
 163 }
 164
 165 static UINT propvar_changetype(PROPVARIANT *changed, PROPVARIANT *property, VARTYPE vt)
 166 {
 167     HRESULT hr;
 168     HMODULE propsys = LoadLibraryA("propsys.dll");
 169     pPropVariantChangeType = (void *)GetProcAddress(propsys, "PropVariantChangeType");
 170
 171     if (!pPropVariantChangeType)
 172     {
 173         ERR("PropVariantChangeType function missing!\n");
 174         return ERROR_FUNCTION_FAILED;
 175     }
 176
 177     hr = pPropVariantChangeType(changed, property, 0, vt);
 178     return (hr == S_OK) ? ERROR_SUCCESS : ERROR_FUNCTION_FAILED;
 179 }
 180
 181 /* FIXME: doesn't deal with endian conversion */
 182 static void read_properties_from_data( PROPVARIANT *prop, LPBYTE data, DWORD sz )
 183 {
 184     UINT type;
 185     DWORD i, size;
 186     PROPERTY_DATA *propdata;
 187     PROPVARIANT property, *ptr;
 188     PROPVARIANT changed;
 189     PROPERTYIDOFFSET *idofs;
 190     PROPERTYSECTIONHEADER *section_hdr;
 191
 192     section_hdr = (PROPERTYSECTIONHEADER*) &data[0];
 193     idofs = (PROPERTYIDOFFSET*) &data[SECT_HDR_SIZE];
 194
 195     /* now set all the properties */
 196     for( i = 0; i < section_hdr->cProperties; i++ )
 197     {
 198         if( idofs[i].propid >= MSI_MAX_PROPS )
 199         {
 200             ERR("Unknown property ID %d\n", idofs[i].propid );
 201             break;
 202         }
 203
 204         type = get_type( idofs[i].propid );
 205         if( type == VT_EMPTY )
 206         {
 207             ERR("propid %d has unknown type\n", idofs[i].propid);
 208             break;
 209         }
 210
 211         propdata = (PROPERTY_DATA*) &data[ idofs[i].dwOffset ];
 212
 213         /* check we don't run off the end of the data */
 214         size = sz - idofs[i].dwOffset - sizeof(DWORD);
 215         if( sizeof(DWORD) > size ||
 216             ( propdata->type == VT_FILETIME && sizeof(FILETIME) > size ) ||
 217             ( propdata->type == VT_LPSTR && (propdata->u.str.len + sizeof(DWORD)) > size ) )
 218         {
 219             ERR("not enough data\n");
 220             break;
 221         }
 222
 223         property.vt = propdata->type;
 224         if( propdata->type == VT_LPSTR )
 225         {
 226             LPSTR str = msi_alloc( propdata->u.str.len );
 227             memcpy( str, propdata->u.str.str, propdata->u.str.len );
 228             str[ propdata->u.str.len - 1 ] = 0;
 229             property.u.pszVal = str;
 230         }
 231         else if( propdata->type == VT_FILETIME )
 232             property.u.filetime = propdata->u.ft;
 233         else if( propdata->type == VT_I2 )
 234             property.u.iVal = propdata->u.i2;
 235         else if( propdata->type == VT_I4 )
 236             property.u.lVal = propdata->u.i4;
 237
 238         /* check the type is the same as we expect */
 239         if( type != propdata->type )
 240         {
 241             propvar_changetype(&changed, &property, type);
 242             ptr = &changed;
 243         }
 244         else
 245             ptr = &property;
 246
 247         prop[ idofs[i].propid ] = *ptr;
 248     }
 249 }
 250
 251 static UINT load_summary_info( MSISUMMARYINFO *si, IStream *stm )
 252 {
 253     PROPERTYSETHEADER set_hdr;
 254     FORMATIDOFFSET format_hdr;
 255     PROPERTYSECTIONHEADER section_hdr;
 256     LPBYTE data = NULL;
 257     LARGE_INTEGER ofs;
 258     ULONG count, sz;
 259     HRESULT r;
 260
 261     TRACE("%p %p\n", si, stm);
 262
 263     /* read the header */
 264     sz = sizeof set_hdr;
 265     r = IStream_Read( stm, &set_hdr, sz, &count );
 266     if( FAILED(r) || count != sz )
 267         return ERROR_FUNCTION_FAILED;
 268
 269     if( set_hdr.wByteOrder != 0xfffe )
 270     {
 271         ERR("property set not big-endian %04X\n", set_hdr.wByteOrder);
 272         return ERROR_FUNCTION_FAILED;
 273     }
 274
 275     sz = sizeof format_hdr;
 276     r = IStream_Read( stm, &format_hdr, sz, &count );
 277     if( FAILED(r) || count != sz )
 278         return ERROR_FUNCTION_FAILED;
 279
 280     /* check the format id is correct */
 281     if( !IsEqualGUID( &FMTID_SummaryInformation, &format_hdr.fmtid ) )
 282         return ERROR_FUNCTION_FAILED;
 283
 284     /* seek to the location of the section */
 285     ofs.QuadPart = format_hdr.dwOffset;
 286     r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, NULL );
 287     if( FAILED(r) )
 288         return ERROR_FUNCTION_FAILED;
 289
 290     /* read the section itself */
 291     sz = SECT_HDR_SIZE;
 292     r = IStream_Read( stm, &section_hdr, sz, &count );
 293     if( FAILED(r) || count != sz )
 294         return ERROR_FUNCTION_FAILED;
 295
 296     if( section_hdr.cProperties > MSI_MAX_PROPS )
 297     {
 298         ERR("too many properties %d\n", section_hdr.cProperties);
 299         return ERROR_FUNCTION_FAILED;
 300     }
 301
 302     data = msi_alloc( section_hdr.cbSection);
 303     if( !data )
 304         return ERROR_FUNCTION_FAILED;
 305
 306     memcpy( data, &section_hdr, SECT_HDR_SIZE );
 307
 308     /* read all the data in one go */
 309     sz = section_hdr.cbSection - SECT_HDR_SIZE;
 310     r = IStream_Read( stm, &data[ SECT_HDR_SIZE ], sz, &count );
 311     if( SUCCEEDED(r) && count == sz )
 312         read_properties_from_data( si->property, data, sz + SECT_HDR_SIZE );
 313     else
 314         ERR("failed to read properties %d %d\n", count, sz);
 315
 316     msi_free( data );
 317     return ERROR_SUCCESS;
 318 }
 319
 320 static DWORD write_dword( LPBYTE data, DWORD ofs, DWORD val )
 321 {
 322     if( data )
 323     {
 324         data[ofs++] = val&0xff;
 325         data[ofs++] = (val>>8)&0xff;
 326         data[ofs++] = (val>>16)&0xff;
 327         data[ofs++] = (val>>24)&0xff;
 328     }
 329     return 4;
 330 }
 331
 332 static DWORD write_filetime( LPBYTE data, DWORD ofs, const FILETIME *ft )
 333 {
 334     write_dword( data, ofs, ft->dwLowDateTime );
 335     write_dword( data, ofs + 4, ft->dwHighDateTime );
 336     return 8;
 337 }
 338
 339 static DWORD write_string( LPBYTE data, DWORD ofs, LPCSTR str )
 340 {
 341     DWORD len = lstrlenA( str ) + 1;
 342     write_dword( data, ofs, len );
 343     if( data )
 344         memcpy( &data[ofs + 4], str, len );
 345     return (7 + len) & ~3;
 346 }
 347
 348 static UINT write_property_to_data( const PROPVARIANT *prop, LPBYTE data )
 349 {
 350     DWORD sz = 0;
 351
 352     if( prop->vt == VT_EMPTY )
 353         return sz;
 354
 355     /* add the type */
 356     sz += write_dword( data, sz, prop->vt );
 357     switch( prop->vt )
 358     {
 359     case VT_I2:
 360         sz += write_dword( data, sz, prop->u.iVal );
 361         break;
 362     case VT_I4:
 363         sz += write_dword( data, sz, prop->u.lVal );
 364         break;
 365     case VT_FILETIME:
 366         sz += write_filetime( data, sz, &prop->u.filetime );
 367         break;
 368     case VT_LPSTR:
 369         sz += write_string( data, sz, prop->u.pszVal );
 370         break;
 371     }
 372     return sz;
 373 }
 374
 375 static UINT save_summary_info( const MSISUMMARYINFO * si, IStream *stm )
 376 {
 377     UINT ret = ERROR_FUNCTION_FAILED;
 378     PROPERTYSETHEADER set_hdr;
 379     FORMATIDOFFSET format_hdr;
 380     PROPERTYSECTIONHEADER section_hdr;
 381     PROPERTYIDOFFSET idofs[MSI_MAX_PROPS];
 382     LPBYTE data = NULL;
 383     ULONG count, sz;
 384     HRESULT r;
 385     int i;
 386
 387     /* write the header */
 388     sz = sizeof set_hdr;
 389     memset( &set_hdr, 0, sz );
 390     set_hdr.wByteOrder = 0xfffe;
 391     set_hdr.wFormat = 0;
 392     set_hdr.dwOSVer = 0x00020005; /* build 5, platform id 2 */
 393     /* set_hdr.clsID is {00000000-0000-0000-0000-000000000000} */
 394     set_hdr.reserved = 1;
 395     r = IStream_Write( stm, &set_hdr, sz, &count );
 396     if( FAILED(r) || count != sz )
 397         return ret;
 398
 399     /* write the format header */
 400     sz = sizeof format_hdr;
 401     format_hdr.fmtid = FMTID_SummaryInformation;
 402     format_hdr.dwOffset = sizeof format_hdr + sizeof set_hdr;
 403     r = IStream_Write( stm, &format_hdr, sz, &count );
 404     if( FAILED(r) || count != sz )
 405         return ret;
 406
 407     /* add up how much space the data will take and calculate the offsets */
 408     section_hdr.cbSection = sizeof section_hdr;
 409     section_hdr.cbSection += (get_property_count( si->property ) * sizeof idofs[0]);
 410     section_hdr.cProperties = 0;
 411     for( i = 0; i < MSI_MAX_PROPS; i++ )
 412     {
 413         sz = write_property_to_data( &si->property[i], NULL );
 414         if( !sz )
 415             continue;
 416         idofs[ section_hdr.cProperties ].propid = i;
 417         idofs[ section_hdr.cProperties ].dwOffset = section_hdr.cbSection;
 418         section_hdr.cProperties++;
 419         section_hdr.cbSection += sz;
 420     }
 421
 422     data = msi_alloc_zero( section_hdr.cbSection );
 423
 424     sz = 0;
 425     memcpy( &data[sz], &section_hdr, sizeof section_hdr );
 426     sz += sizeof section_hdr;
 427
 428     memcpy( &data[sz], idofs, section_hdr.cProperties * sizeof idofs[0] );
 429     sz += section_hdr.cProperties * sizeof idofs[0];
 430
 431     /* write out the data */
 432     for( i = 0; i < MSI_MAX_PROPS; i++ )
 433         sz += write_property_to_data( &si->property[i], &data[sz] );
 434
 435     r = IStream_Write( stm, data, sz, &count );
 436     msi_free( data );
 437     if( FAILED(r) || count != sz )
 438         return ret;
 439
 440     return ERROR_SUCCESS;
 441 }
 442
 443 static MSISUMMARYINFO *create_suminfo( IStorage *stg, UINT update_count )
 444 {
 445     MSISUMMARYINFO *si;
 446
 447     if (!(si = alloc_msiobject( MSIHANDLETYPE_SUMMARYINFO, sizeof(MSISUMMARYINFO), MSI_CloseSummaryInfo )))
 448         return NULL;
 449
 450     si->update_count = update_count;
 451     IStorage_AddRef( stg );
 452     si->storage = stg;
 453
 454     return si;
 455 }
 456
 457 UINT msi_get_suminfo( IStorage *stg, UINT uiUpdateCount, MSISUMMARYINFO **ret )
 458 {
 459     IStream *stm;
 460     MSISUMMARYINFO *si;
 461     HRESULT hr;
 462     UINT r;
 463
 464     TRACE("%p, %u\n", stg, uiUpdateCount);
 465
 466     if (!(si = create_suminfo( stg, uiUpdateCount ))) return ERROR_OUTOFMEMORY;
 467
 468     hr = IStorage_OpenStream( si->storage, szSumInfo, 0, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &stm );
 469     if (FAILED( hr ))
 470     {
 471         msiobj_release( &si->hdr );
 472         return ERROR_FUNCTION_FAILED;
 473     }
 474
 475     r = load_summary_info( si, stm );
 476     IStream_Release( stm );
 477     if (r != ERROR_SUCCESS)
 478     {
 479         msiobj_release( &si->hdr );
 480         return r;
 481     }
 482
 483     *ret = si;
 484     return ERROR_SUCCESS;
 485 }
 486
 487 UINT msi_get_db_suminfo( MSIDATABASE *db, UINT uiUpdateCount, MSISUMMARYINFO **ret )
 488 {
 489     IStream *stm;
 490     MSISUMMARYINFO *si;
 491     UINT r;
 492
 493     if (!(si = create_suminfo( db->storage, uiUpdateCount ))) return ERROR_OUTOFMEMORY;
 494
 495     r = msi_get_stream( db, szSumInfo, &stm );
 496     if (r != ERROR_SUCCESS)
 497     {
 498         msiobj_release( &si->hdr );
 499         return r;
 500     }
 501
 502     r = load_summary_info( si, stm );
 503     IStream_Release( stm );
 504     if (r != ERROR_SUCCESS)
 505     {
 506         msiobj_release( &si->hdr );
 507         return r;
 508     }
 509
 510     *ret = si;
 511     return ERROR_SUCCESS;
 512 }
 513
 514 UINT WINAPI MsiGetSummaryInformationW( MSIHANDLE hDatabase,
 515               LPCWSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle )
 516 {
 517     MSISUMMARYINFO *si;
 518     MSIDATABASE *db;
 519     UINT ret;
 520
 521     TRACE("%d %s %d %p\n", hDatabase, debugstr_w(szDatabase),
 522            uiUpdateCount, pHandle);
 523
 524     if( !pHandle )
 525         return ERROR_INVALID_PARAMETER;
 526
 527     if( szDatabase && szDatabase[0] )
 528     {
 529         LPCWSTR persist = uiUpdateCount ? MSIDBOPEN_TRANSACT : MSIDBOPEN_READONLY;
 530
 531         ret = MSI_OpenDatabaseW( szDatabase, persist, &db );
 532         if( ret != ERROR_SUCCESS )
 533             return ret;
 534     }
 535     else
 536     {
 537         db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE );
 538         if( !db )
 539         {
 540             HRESULT hr;
 541             IWineMsiRemoteDatabase *remote_database;
 542
 543             remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hDatabase );
 544             if ( !remote_database )
 545                 return ERROR_INVALID_HANDLE;
 546
 547             hr = IWineMsiRemoteDatabase_GetSummaryInformation( remote_database,
 548                                                                uiUpdateCount, pHandle );
 549             IWineMsiRemoteDatabase_Release( remote_database );
 550
 551             if (FAILED(hr))
 552             {
 553                 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
 554                     return HRESULT_CODE(hr);
 555
 556                 return ERROR_FUNCTION_FAILED;
 557             }
 558
 559             return ERROR_SUCCESS;
 560         }
 561     }
 562
 563     ret = msi_get_suminfo( db->storage, uiUpdateCount, &si );
 564     if (ret != ERROR_SUCCESS)
 565         ret = msi_get_db_suminfo( db, uiUpdateCount, &si );
 566     if (ret != ERROR_SUCCESS)
 567     {
 568         if ((si = create_suminfo( db->storage, uiUpdateCount )))
 569             ret = ERROR_SUCCESS;
 570     }
 571
 572     if (ret == ERROR_SUCCESS)
 573     {
 574         *pHandle = alloc_msihandle( &si->hdr );
 575         if( *pHandle )
 576             ret = ERROR_SUCCESS;
 577         else
 578             ret = ERROR_NOT_ENOUGH_MEMORY;
 579         msiobj_release( &si->hdr );
 580     }
 581
 582     msiobj_release( &db->hdr );
 583     return ret;
 584 }
 585
 586 UINT WINAPI MsiGetSummaryInformationA(MSIHANDLE hDatabase,
 587               LPCSTR szDatabase, UINT uiUpdateCount, MSIHANDLE *pHandle)
 588 {
 589     LPWSTR szwDatabase = NULL;
 590     UINT ret;
 591
 592     TRACE("%d %s %d %p\n", hDatabase, debugstr_a(szDatabase),
 593           uiUpdateCount, pHandle);
 594
 595     if( szDatabase )
 596     {
 597         szwDatabase = strdupAtoW( szDatabase );
 598         if( !szwDatabase )
 599             return ERROR_FUNCTION_FAILED;
 600     }
 601
 602     ret = MsiGetSummaryInformationW(hDatabase, szwDatabase, uiUpdateCount, pHandle);
 603
 604     msi_free( szwDatabase );
 605
 606     return ret;
 607 }
 608
 609 UINT WINAPI MsiSummaryInfoGetPropertyCount(MSIHANDLE hSummaryInfo, PUINT pCount)
 610 {
 611     MSISUMMARYINFO *si;
 612
 613     TRACE("%d %p\n", hSummaryInfo, pCount);
 614
 615     si = msihandle2msiinfo( hSummaryInfo, MSIHANDLETYPE_SUMMARYINFO );
 616     if( !si )
 617         return ERROR_INVALID_HANDLE;
 618
 619     if( pCount )
 620         *pCount = get_property_count( si->property );
 621     msiobj_release( &si->hdr );
 622
 623     return ERROR_SUCCESS;
 624 }
 625
 626 static UINT get_prop( MSISUMMARYINFO *si, UINT uiProperty, UINT *puiDataType, INT *piValue,
 627                       FILETIME *pftValue, awstring *str, DWORD *pcchValueBuf)
 628 {
 629     PROPVARIANT *prop;
 630     UINT ret = ERROR_SUCCESS;
 631
 632     prop = &si->property[uiProperty];
 633
 634     if( puiDataType )
 635         *puiDataType = prop->vt;
 636
 637     switch( prop->vt )
 638     {
 639     case VT_I2:
 640         if( piValue )
 641             *piValue = prop->u.iVal;
 642         break;
 643     case VT_I4:
 644         if( piValue )
 645             *piValue = prop->u.lVal;
 646         break;
 647     case VT_LPSTR:
 648         if( pcchValueBuf )
 649         {
 650             DWORD len = 0;
 651
 652             if( str->unicode )
 653             {
 654                 len = MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1, NULL, 0 ) - 1;
 655                 MultiByteToWideChar( CP_ACP, 0, prop->u.pszVal, -1, str->str.w, *pcchValueBuf );
 656             }
 657             else
 658             {
 659                 len = lstrlenA( prop->u.pszVal );
 660                 if( str->str.a )
 661                     lstrcpynA(str->str.a, prop->u.pszVal, *pcchValueBuf );
 662             }
 663             if (len >= *pcchValueBuf)
 664                 ret = ERROR_MORE_DATA;
 665             *pcchValueBuf = len;
 666         }
 667         break;
 668     case VT_FILETIME:
 669         if( pftValue )
 670             *pftValue = prop->u.filetime;
 671         break;
 672     case VT_EMPTY:
 673         break;
 674     default:
 675         FIXME("Unknown property variant type\n");
 676         break;
 677     }
 678     return ret;
 679 }
 680
 681 LPWSTR msi_suminfo_dup_string( MSISUMMARYINFO *si, UINT uiProperty )
 682 {
 683     PROPVARIANT *prop;
 684
 685     if ( uiProperty >= MSI_MAX_PROPS )
 686         return NULL;
 687     prop = &si->property[uiProperty];
 688     if( prop->vt != VT_LPSTR )
 689         return NULL;
 690     return strdupAtoW( prop->u.pszVal );
 691 }
 692
 693 INT msi_suminfo_get_int32( MSISUMMARYINFO *si, UINT uiProperty )
 694 {
 695     PROPVARIANT *prop;
 696
 697     if ( uiProperty >= MSI_MAX_PROPS )
 698         return -1;
 699     prop = &si->property[uiProperty];
 700     if( prop->vt != VT_I4 )
 701         return -1;
 702     return prop->u.lVal;
 703 }
 704
 705 LPWSTR msi_get_suminfo_product( IStorage *stg )
 706 {
 707     MSISUMMARYINFO *si;
 708     LPWSTR prod;
 709     UINT r;
 710
 711     r = msi_get_suminfo( stg, 0, &si );
 712     if (r != ERROR_SUCCESS)
 713     {
 714         ERR("no summary information!\n");
 715         return NULL;
 716     }
 717     prod = msi_suminfo_dup_string( si, PID_REVNUMBER );
 718     msiobj_release( &si->hdr );
 719     return prod;
 720 }
 721
 722 UINT WINAPI MsiSummaryInfoGetPropertyA(
 723       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
 724       FILETIME *pftValue, LPSTR szValueBuf, LPDWORD pcchValueBuf)
 725 {
 726     MSISUMMARYINFO *si;
 727     awstring str;
 728     UINT r;
 729
 730     TRACE("%u, %u, %p, %p, %p, %p, %p\n", handle, uiProperty, puiDataType,
 731           piValue, pftValue, szValueBuf, pcchValueBuf );
 732
 733     if (uiProperty >= MSI_MAX_PROPS)
 734     {
 735         if (puiDataType) *puiDataType = VT_EMPTY;
 736         return ERROR_UNKNOWN_PROPERTY;
 737     }
 738
 739     if (!(si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO )))
 740         return ERROR_INVALID_HANDLE;
 741
 742     str.unicode = FALSE;
 743     str.str.a = szValueBuf;
 744
 745     r = get_prop( si, uiProperty, puiDataType, piValue, pftValue, &str, pcchValueBuf );
 746     msiobj_release( &si->hdr );
 747     return r;
 748 }
 749
 750 UINT WINAPI MsiSummaryInfoGetPropertyW(
 751       MSIHANDLE handle, UINT uiProperty, PUINT puiDataType, LPINT piValue,
 752       FILETIME *pftValue, LPWSTR szValueBuf, LPDWORD pcchValueBuf)
 753 {
 754     MSISUMMARYINFO *si;
 755     awstring str;
 756     UINT r;
 757
 758     TRACE("%u, %u, %p, %p, %p, %p, %p\n", handle, uiProperty, puiDataType,
 759           piValue, pftValue, szValueBuf, pcchValueBuf );
 760
 761     if (uiProperty >= MSI_MAX_PROPS)
 762     {
 763         if (puiDataType) *puiDataType = VT_EMPTY;
 764         return ERROR_UNKNOWN_PROPERTY;
 765     }
 766
 767     if (!(si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO )))
 768         return ERROR_INVALID_HANDLE;
 769
 770     str.unicode = TRUE;
 771     str.str.w = szValueBuf;
 772
 773     r = get_prop( si, uiProperty, puiDataType, piValue, pftValue, &str, pcchValueBuf );
 774     msiobj_release( &si->hdr );
 775     return r;
 776 }
 777
 778 static UINT set_prop( MSISUMMARYINFO *si, UINT uiProperty, UINT type,
 779                       INT iValue, FILETIME *pftValue, awcstring *str )
 780 {
 781     PROPVARIANT *prop;
 782     UINT len;
 783
 784     TRACE("%p, %u, %u, %d, %p, %p\n", si, uiProperty, type, iValue, pftValue, str );
 785
 786     prop = &si->property[uiProperty];
 787
 788     if( prop->vt == VT_EMPTY )
 789     {
 790         if( !si->update_count )
 791             return ERROR_FUNCTION_FAILED;
 792
 793         si->update_count--;
 794     }
 795     else if( prop->vt != type )
 796         return ERROR_SUCCESS;
 797
 798     free_prop( prop );
 799     prop->vt = type;
 800     switch( type )
 801     {
 802     case VT_I4:
 803         prop->u.lVal = iValue;
 804         break;
 805     case VT_I2:
 806         prop->u.iVal = iValue;
 807         break;
 808     case VT_FILETIME:
 809         prop->u.filetime = *pftValue;
 810         break;
 811     case VT_LPSTR:
 812         if( str->unicode )
 813         {
 814             len = WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
 815                                        NULL, 0, NULL, NULL );
 816             prop->u.pszVal = msi_alloc( len );
 817             WideCharToMultiByte( CP_ACP, 0, str->str.w, -1,
 818                                  prop->u.pszVal, len, NULL, NULL );
 819         }
 820         else
 821         {
 822             len = lstrlenA( str->str.a ) + 1;
 823             prop->u.pszVal = msi_alloc( len );
 824             lstrcpyA( prop->u.pszVal, str->str.a );
 825         }
 826         break;
 827     }
 828
 829     return ERROR_SUCCESS;
 830 }
 831
 832 UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE handle, UINT uiProperty, UINT uiDataType,
 833                                         INT iValue, FILETIME *pftValue, LPCWSTR szValue )
 834 {
 835     awcstring str;
 836     MSISUMMARYINFO *si;
 837     UINT type, ret;
 838
 839     TRACE("%u, %u, %u, %d, %p, %s\n", handle, uiProperty, uiDataType, iValue, pftValue,
 840           debugstr_w(szValue) );
 841
 842     type = get_type( uiProperty );
 843     if( type == VT_EMPTY || type != uiDataType )
 844         return ERROR_DATATYPE_MISMATCH;
 845
 846     if( uiDataType == VT_LPSTR && !szValue )
 847         return ERROR_INVALID_PARAMETER;
 848
 849     if( uiDataType == VT_FILETIME && !pftValue )
 850         return ERROR_INVALID_PARAMETER;
 851
 852     if (!(si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO )))
 853         return ERROR_INVALID_HANDLE;
 854
 855     str.unicode = TRUE;
 856     str.str.w = szValue;
 857
 858     ret = set_prop( si, uiProperty, type, iValue, pftValue, &str );
 859     msiobj_release( &si->hdr );
 860     return ret;
 861 }
 862
 863 UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE handle, UINT uiProperty, UINT uiDataType,
 864                                         INT iValue, FILETIME *pftValue, LPCSTR szValue )
 865 {
 866     awcstring str;
 867     MSISUMMARYINFO *si;
 868     UINT type, ret;
 869
 870     TRACE("%u, %u, %u, %d, %p, %s\n", handle, uiProperty, uiDataType, iValue, pftValue,
 871           debugstr_a(szValue) );
 872
 873     type = get_type( uiProperty );
 874     if( type == VT_EMPTY || type != uiDataType )
 875         return ERROR_DATATYPE_MISMATCH;
 876
 877     if( uiDataType == VT_LPSTR && !szValue )
 878         return ERROR_INVALID_PARAMETER;
 879
 880     if( uiDataType == VT_FILETIME && !pftValue )
 881         return ERROR_INVALID_PARAMETER;
 882
 883     if (!(si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO )))
 884         return ERROR_INVALID_HANDLE;
 885
 886     str.unicode = FALSE;
 887     str.str.a = szValue;
 888
 889     ret = set_prop( si, uiProperty, uiDataType, iValue, pftValue, &str );
 890     msiobj_release( &si->hdr );
 891     return ret;
 892 }
 893
 894 static UINT suminfo_persist( MSISUMMARYINFO *si )
 895 {
 896     UINT ret = ERROR_FUNCTION_FAILED;
 897     IStream *stm = NULL;
 898     DWORD grfMode;
 899     HRESULT r;
 900
 901     grfMode = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
 902     r = IStorage_CreateStream( si->storage, szSumInfo, grfMode, 0, 0, &stm );
 903     if( SUCCEEDED(r) )
 904     {
 905         ret = save_summary_info( si, stm );
 906         IStream_Release( stm );
 907     }
 908     return ret;
 909 }
 910
 911 static void parse_filetime( LPCWSTR str, FILETIME *ft )
 912 {
 913     SYSTEMTIME lt, utc;
 914     const WCHAR *p = str;
 915     WCHAR *end;
 916
 917     memset( &lt, 0, sizeof(lt) );
 918
 919     /* YYYY/MM/DD hh:mm:ss */
 920
 921     while (isspaceW( *p )) p++;
 922
 923     lt.wYear = strtolW( p, &end, 10 );
 924     if (*end != '/') return;
 925     p = end + 1;
 926
 927     lt.wMonth = strtolW( p, &end, 10 );
 928     if (*end != '/') return;
 929     p = end + 1;
 930
 931     lt.wDay = strtolW( p, &end, 10 );
 932     if (*end != ' ') return;
 933     p = end + 1;
 934
 935     while (isspaceW( *p )) p++;
 936
 937     lt.wHour = strtolW( p, &end, 10 );
 938     if (*end != ':') return;
 939     p = end + 1;
 940
 941     lt.wMinute = strtolW( p, &end, 10 );
 942     if (*end != ':') return;
 943     p = end + 1;
 944
 945     lt.wSecond = strtolW( p, &end, 10 );
 946
 947     TzSpecificLocalTimeToSystemTime( NULL, &lt, &utc );
 948     SystemTimeToFileTime( &utc, ft );
 949 }
 950
 951 static UINT parse_prop( LPCWSTR prop, LPCWSTR value, UINT *pid, INT *int_value,
 952                         FILETIME *ft_value, awcstring *str_value )
 953 {
 954     *pid = atoiW( prop );
 955     switch (*pid)
 956     {
 957 #ifdef __REACTOS__
 958     case PID_CODEPAGE_MSI:
 959 #else
 960     case PID_CODEPAGE:
 961 #endif
 962     case PID_WORDCOUNT:
 963     case PID_CHARCOUNT:
 964 #ifdef __REACTOS__
 965     case PID_SECURITY_MSI:
 966 #else
 967     case PID_SECURITY:
 968 #endif
 969     case PID_PAGECOUNT:
 970         *int_value = atoiW( value );
 971         break;
 972
 973     case PID_LASTPRINTED:
 974     case PID_CREATE_DTM:
 975     case PID_LASTSAVE_DTM:
 976         parse_filetime( value, ft_value );
 977         break;
 978
 979     case PID_SUBJECT:
 980     case PID_AUTHOR:
 981     case PID_KEYWORDS:
 982     case PID_COMMENTS:
 983     case PID_TEMPLATE:
 984     case PID_LASTAUTHOR:
 985     case PID_REVNUMBER:
 986     case PID_APPNAME:
 987     case PID_TITLE:
 988         str_value->str.w = value;
 989         str_value->unicode = TRUE;
 990         break;
 991
 992     default:
 993         WARN("unhandled prop id %u\n", *pid);
 994         return ERROR_FUNCTION_FAILED;
 995     }
 996
 997     return ERROR_SUCCESS;
 998 }
 999
1000 UINT msi_add_suminfo( MSIDATABASE *db, LPWSTR **records, int num_records, int num_columns )
1001 {
1002     UINT r;
1003     int i, j;
1004     MSISUMMARYINFO *si;
1005
1006     r = msi_get_suminfo( db->storage, num_records * (num_columns / 2), &si );
1007     if (r != ERROR_SUCCESS)
1008     {
1009         if (!(si = create_suminfo( db->storage, num_records * (num_columns / 2) )))
1010             return ERROR_OUTOFMEMORY;
1011         r = ERROR_SUCCESS;
1012     }
1013
1014     for (i = 0; i < num_records; i++)
1015     {
1016         for (j = 0; j < num_columns; j += 2)
1017         {
1018             UINT pid;
1019             INT int_value = 0;
1020             FILETIME ft_value;
1021             awcstring str_value;
1022
1023             r = parse_prop( records[i][j], records[i][j + 1], &pid, &int_value, &ft_value, &str_value );
1024             if (r != ERROR_SUCCESS)
1025                 goto end;
1026
1027             r = set_prop( si, pid, get_type(pid), int_value, &ft_value, &str_value );
1028             if (r != ERROR_SUCCESS)
1029                 goto end;
1030         }
1031     }
1032
1033 end:
1034     if (r == ERROR_SUCCESS)
1035         r = suminfo_persist( si );
1036
1037     msiobj_release( &si->hdr );
1038     return r;
1039 }
1040
1041 static UINT save_prop( MSISUMMARYINFO *si, HANDLE handle, UINT row )
1042 {
1043     static const char fmt_systemtime[] = "%d/%02d/%02d %02d:%02d:%02d";
1044     char data[20]; /* largest string: YYYY/MM/DD hh:mm:ss */
1045     static const char fmt_begin[] = "%u\t";
1046     static const char data_end[] = "\r\n";
1047     static const char fmt_int[] = "%u";
1048     UINT r, data_type, len;
1049     SYSTEMTIME system_time;
1050     FILETIME file_time;
1051     INT int_value;
1052     awstring str;
1053     DWORD sz;
1054
1055     str.unicode = FALSE;
1056     str.str.a = NULL;
1057     len = 0;
1058     r = get_prop( si, row, &data_type, &int_value, &file_time, &str, &len );
1059     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
1060         return r;
1061     if (data_type == VT_EMPTY)
1062         return ERROR_SUCCESS; /* property not set */
1063     snprintf( data, sizeof(data), fmt_begin, row );
1064     sz = lstrlenA( data );
1065     if (!WriteFile( handle, data, sz, &sz, NULL ))
1066         return ERROR_WRITE_FAULT;
1067
1068     switch (data_type)
1069     {
1070     case VT_I2:
1071     case VT_I4:
1072         snprintf( data, sizeof(data), fmt_int, int_value );
1073         sz = lstrlenA( data );
1074         if (!WriteFile( handle, data, sz, &sz, NULL ))
1075             return ERROR_WRITE_FAULT;
1076         break;
1077     case VT_LPSTR:
1078         len++;
1079         if (!(str.str.a = msi_alloc( len )))
1080             return ERROR_OUTOFMEMORY;
1081         r = get_prop( si, row, NULL, NULL, NULL, &str, &len );
1082         if (r != ERROR_SUCCESS)
1083         {
1084             msi_free( str.str.a );
1085             return r;
1086         }
1087         sz = lstrlenA( str.str.a );
1088         if (!WriteFile( handle, str.str.a, sz, &sz, NULL ))
1089         {
1090             msi_free( str.str.a );
1091             return ERROR_WRITE_FAULT;
1092         }
1093         msi_free( str.str.a );
1094         break;
1095     case VT_FILETIME:
1096         if (!FileTimeToSystemTime( &file_time, &system_time ))
1097             return ERROR_FUNCTION_FAILED;
1098         snprintf( data, sizeof(data), fmt_systemtime, system_time.wYear, system_time.wMonth,
1099                   system_time.wDay, system_time.wHour, system_time.wMinute,
1100                   system_time.wSecond );
1101         sz = lstrlenA( data );
1102         if (!WriteFile( handle, data, sz, &sz, NULL ))
1103             return ERROR_WRITE_FAULT;
1104         break;
1105     case VT_EMPTY:
1106         /* cannot reach here, property not set */
1107         break;
1108     default:
1109         FIXME( "Unknown property variant type\n" );
1110         return ERROR_FUNCTION_FAILED;
1111     }
1112
1113     sz = lstrlenA( data_end );
1114     if (!WriteFile( handle, data_end, sz, &sz, NULL ))
1115         return ERROR_WRITE_FAULT;
1116
1117     return ERROR_SUCCESS;
1118 }
1119
1120 UINT msi_export_suminfo( MSIDATABASE *db, HANDLE handle )
1121 {
1122     UINT i, r, num_rows;
1123     MSISUMMARYINFO *si;
1124
1125     r = msi_get_suminfo( db->storage, 0, &si );
1126     if (r != ERROR_SUCCESS)
1127         r = msi_get_db_suminfo( db, 0, &si );
1128     if (r != ERROR_SUCCESS)
1129         return r;
1130
1131     num_rows = get_property_count( si->property );
1132     if (!num_rows)
1133     {
1134         msiobj_release( &si->hdr );
1135         return ERROR_FUNCTION_FAILED;
1136     }
1137
1138     for (i = 0; i < num_rows; i++)
1139     {
1140         r = save_prop( si, handle, i );
1141         if (r != ERROR_SUCCESS)
1142         {
1143             msiobj_release( &si->hdr );
1144             return r;
1145         }
1146     }
1147
1148     msiobj_release( &si->hdr );
1149     return ERROR_SUCCESS;
1150 }
1151
1152 UINT WINAPI MsiSummaryInfoPersist( MSIHANDLE handle )
1153 {
1154     MSISUMMARYINFO *si;
1155     UINT ret;
1156
1157     TRACE("%d\n", handle );
1158
1159     si = msihandle2msiinfo( handle, MSIHANDLETYPE_SUMMARYINFO );
1160     if( !si )
1161         return ERROR_INVALID_HANDLE;
1162
1163     ret = suminfo_persist( si );
1164
1165     msiobj_release( &si->hdr );
1166     return ret;
1167 }
1168
1169 UINT WINAPI MsiCreateTransformSummaryInfoA( MSIHANDLE db, MSIHANDLE db_ref, LPCSTR transform, int error, int validation )
1170 {
1171     UINT r;
1172     WCHAR *transformW = NULL;
1173
1174     TRACE("%u, %u, %s, %d, %d\n", db, db_ref, debugstr_a(transform), error, validation);
1175
1176     if (transform && !(transformW = strdupAtoW( transform )))
1177         return ERROR_OUTOFMEMORY;
1178
1179     r = MsiCreateTransformSummaryInfoW( db, db_ref, transformW, error, validation );
1180     msi_free( transformW );
1181     return r;
1182 }
1183
1184 UINT WINAPI MsiCreateTransformSummaryInfoW( MSIHANDLE db, MSIHANDLE db_ref, LPCWSTR transform, int error, int validation )
1185 {
1186     FIXME("%u, %u, %s, %d, %d\n", db, db_ref, debugstr_w(transform), error, validation);
1187     return ERROR_FUNCTION_FAILED;
1188 }
1189
1190 UINT msi_load_suminfo_properties( MSIPACKAGE *package )
1191 {
1192     static const WCHAR packagecodeW[] = {'P','a','c','k','a','g','e','C','o','d','e',0};
1193     MSISUMMARYINFO *si;
1194     WCHAR *package_code;
1195     UINT r, len;
1196     awstring str;
1197     INT count;
1198
1199     r = msi_get_suminfo( package->db->storage, 0, &si );
1200     if (r != ERROR_SUCCESS)
1201     {
1202         r = msi_get_db_suminfo( package->db, 0, &si );
1203         if (r != ERROR_SUCCESS)
1204         {
1205             ERR("Unable to open summary information stream %u\n", r);
1206             return r;
1207         }
1208     }
1209
1210     str.unicode = TRUE;
1211     str.str.w = NULL;
1212     len = 0;
1213     r = get_prop( si, PID_REVNUMBER, NULL, NULL, NULL, &str, &len );
1214     if (r != ERROR_MORE_DATA)
1215     {
1216         WARN("Unable to query revision number %u\n", r);
1217         msiobj_release( &si->hdr );
1218         return ERROR_FUNCTION_FAILED;
1219     }
1220
1221     len++;
1222     if (!(package_code = msi_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
1223     str.str.w = package_code;
1224
1225     r = get_prop( si, PID_REVNUMBER, NULL, NULL, NULL, &str, &len );
1226     if (r != ERROR_SUCCESS)
1227     {
1228         msi_free( package_code );
1229         msiobj_release( &si->hdr );
1230         return r;
1231     }
1232
1233     r = msi_set_property( package->db, packagecodeW, package_code, len );
1234     msi_free( package_code );
1235
1236     count = 0;
1237     get_prop( si, PID_WORDCOUNT, NULL, &count, NULL, NULL, NULL );
1238     package->WordCount = count;
1239
1240     msiobj_release( &si->hdr );
1241     return r;
1242 }