dlls/msi/record.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2002-2004 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
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "winerror.h"
  29 #include "wine/debug.h"
  30 #include "msi.h"
  31 #include "msiquery.h"
  32 #include "msipriv.h"
  33 #include "objidl.h"
  34 #include "winnls.h"
  35 #include "ole2.h"
  36
  37 #include "winreg.h"
  38 #include "shlwapi.h"
  39
  40 #include "query.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  43
  44 #define MSIFIELD_NULL   0
  45 #define MSIFIELD_INT    1
  46 #define MSIFIELD_STR    2
  47 #define MSIFIELD_WSTR   3
  48 #define MSIFIELD_STREAM 4
  49
  50 static void MSI_FreeField( MSIFIELD *field )
  51 {
  52     switch( field->type )
  53     {
  54     case MSIFIELD_NULL:
  55     case MSIFIELD_INT:
  56         break;
  57     case MSIFIELD_WSTR:
  58         HeapFree( GetProcessHeap(), 0, field->u.szwVal);
  59         break;
  60     case MSIFIELD_STREAM:
  61         IStream_Release( field->u.stream );
  62         break;
  63     default:
  64         ERR("Invalid field type %d\n", field->type);
  65     }
  66 }
  67
  68 static void MSI_CloseRecord( MSIOBJECTHDR *arg )
  69 {
  70     MSIRECORD *rec = (MSIRECORD *) arg;
  71     UINT i;
  72
  73     for( i=0; i<=rec->count; i++ )
  74         MSI_FreeField( &rec->fields[i] );
  75 }
  76
  77 MSIRECORD *MSI_CreateRecord( unsigned int cParams )
  78 {
  79     MSIRECORD *rec;
  80     UINT len;
  81
  82     TRACE("%d\n", cParams);
  83
  84     if( cParams>65535 )
  85         return NULL;
  86
  87     len = sizeof (MSIRECORD) + sizeof (MSIFIELD)*cParams;
  88     rec = alloc_msiobject( MSIHANDLETYPE_RECORD, len, MSI_CloseRecord );
  89     if( rec )
  90         rec->count = cParams;
  91     return rec;
  92 }
  93
  94 MSIHANDLE WINAPI MsiCreateRecord( unsigned int cParams )
  95 {
  96     MSIRECORD *rec;
  97     MSIHANDLE ret = 0;
  98
  99     TRACE("%d\n", cParams);
 100
 101     rec = MSI_CreateRecord( cParams );
 102     if( rec )
 103         ret = alloc_msihandle( &rec->hdr );
 104     msiobj_release( &rec->hdr );
 105     return ret;
 106 }
 107
 108 unsigned int MSI_RecordGetFieldCount( MSIRECORD *rec )
 109 {
 110     return rec->count;
 111 }
 112
 113 unsigned int WINAPI MsiRecordGetFieldCount( MSIHANDLE handle )
 114 {
 115     MSIRECORD *rec;
 116     UINT ret;
 117
 118     TRACE("%ld\n", handle );
 119
 120     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 121     if( !rec )
 122         return -1;
 123
 124     msiobj_lock( &rec->hdr );
 125     ret = MSI_RecordGetFieldCount( rec );
 126     msiobj_unlock( &rec->hdr );
 127     msiobj_release( &rec->hdr );
 128
 129     return ret;
 130 }
 131
 132 static BOOL string2intW( LPCWSTR str, int *out )
 133 {
 134     int x = 0;
 135     LPCWSTR p = str;
 136
 137     if( *p == '-' ) /* skip the minus sign */
 138         p++;
 139     while ( *p )
 140     {
 141         if( (*p < '0') || (*p > '9') )
 142             return FALSE;
 143         x *= 10;
 144         x += (*p - '0');
 145         p++;
 146     }
 147
 148     if( str[0] == '-' ) /* check if it's negative */
 149         x = -x;
 150     *out = x;
 151
 152     return TRUE;
 153 }
 154
 155 int MSI_RecordGetInteger( MSIRECORD *rec, unsigned int iField)
 156 {
 157     int ret = 0;
 158
 159     TRACE("%p %d\n", rec, iField );
 160
 161     if( iField > rec->count )
 162         return MSI_NULL_INTEGER;
 163
 164     switch( rec->fields[iField].type )
 165     {
 166     case MSIFIELD_INT:
 167         return rec->fields[iField].u.iVal;
 168     case MSIFIELD_WSTR:
 169         if( string2intW( rec->fields[iField].u.szwVal, &ret ) )
 170             return ret;
 171         return MSI_NULL_INTEGER;
 172     default:
 173         break;
 174     }
 175
 176     return MSI_NULL_INTEGER;
 177 }
 178
 179 int WINAPI MsiRecordGetInteger( MSIHANDLE handle, unsigned int iField)
 180 {
 181     MSIRECORD *rec;
 182     UINT ret;
 183
 184     TRACE("%ld %d\n", handle, iField );
 185
 186     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 187     if( !rec )
 188         return MSI_NULL_INTEGER;
 189
 190     msiobj_lock( &rec->hdr );
 191     ret = MSI_RecordGetInteger( rec, iField );
 192     msiobj_unlock( &rec->hdr );
 193     msiobj_release( &rec->hdr );
 194
 195     return ret;
 196 }
 197
 198 UINT WINAPI MsiRecordClearData( MSIHANDLE handle )
 199 {
 200     MSIRECORD *rec;
 201     UINT i;
 202
 203     TRACE("%ld\n", handle );
 204
 205     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 206     if( !rec )
 207         return ERROR_INVALID_HANDLE;
 208
 209     msiobj_lock( &rec->hdr );
 210     for( i=0; i<=rec->count; i++)
 211     {
 212         MSI_FreeField( &rec->fields[i] );
 213         rec->fields[i].type = MSIFIELD_NULL;
 214         rec->fields[i].u.iVal = 0;
 215     }
 216     msiobj_unlock( &rec->hdr );
 217     msiobj_release( &rec->hdr );
 218
 219     return ERROR_SUCCESS;
 220 }
 221
 222 UINT MSI_RecordSetInteger( MSIRECORD *rec, unsigned int iField, int iVal )
 223 {
 224     TRACE("%p %u %d\n", rec, iField, iVal);
 225
 226     if( iField > rec->count )
 227         return ERROR_INVALID_PARAMETER;
 228
 229     MSI_FreeField( &rec->fields[iField] );
 230     rec->fields[iField].type = MSIFIELD_INT;
 231     rec->fields[iField].u.iVal = iVal;
 232
 233     return ERROR_SUCCESS;
 234 }
 235
 236 UINT WINAPI MsiRecordSetInteger( MSIHANDLE handle, unsigned int iField, int iVal )
 237 {
 238     MSIRECORD *rec;
 239     UINT ret;
 240
 241     TRACE("%ld %u %d\n", handle, iField, iVal);
 242
 243     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 244     if( !rec )
 245         return ERROR_INVALID_HANDLE;
 246
 247     msiobj_lock( &rec->hdr );
 248     ret = MSI_RecordSetInteger( rec, iField, iVal );
 249     msiobj_unlock( &rec->hdr );
 250     msiobj_release( &rec->hdr );
 251     return ret;
 252 }
 253
 254 BOOL MSI_RecordIsNull( MSIRECORD *rec, unsigned int iField )
 255 {
 256     BOOL r = TRUE;
 257
 258     TRACE("%p %d\n", rec, iField );
 259
 260     r = ( iField > rec->count ) ||
 261         ( rec->fields[iField].type == MSIFIELD_NULL );
 262
 263     return r;
 264 }
 265
 266 BOOL WINAPI MsiRecordIsNull( MSIHANDLE handle, unsigned int iField )
 267 {
 268     MSIRECORD *rec;
 269     UINT ret;
 270
 271     TRACE("%ld %d\n", handle, iField );
 272
 273     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 274     if( !rec )
 275         return 0;
 276     msiobj_lock( &rec->hdr );
 277     ret = MSI_RecordIsNull( rec, iField );
 278     msiobj_unlock( &rec->hdr );
 279     msiobj_release( &rec->hdr );
 280     return ret;
 281
 282 }
 283
 284 UINT MSI_RecordGetStringA(MSIRECORD *rec, unsigned int iField,
 285                LPSTR szValue, DWORD *pcchValue)
 286 {
 287     UINT len=0, ret;
 288     CHAR buffer[16];
 289
 290     TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue);
 291
 292     if( iField > rec->count )
 293         return ERROR_INVALID_PARAMETER;
 294
 295     ret = ERROR_SUCCESS;
 296     switch( rec->fields[iField].type )
 297     {
 298     case MSIFIELD_INT:
 299         wsprintfA(buffer, "%d", rec->fields[iField].u.iVal);
 300         len = lstrlenA( buffer );
 301         lstrcpynA(szValue, buffer, *pcchValue);
 302         break;
 303     case MSIFIELD_WSTR:
 304         len = WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal, -1,
 305                              NULL, 0 , NULL, NULL);
 306         WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal, -1,
 307                              szValue, *pcchValue, NULL, NULL);
 308         if( *pcchValue && len>*pcchValue )
 309             szValue[*pcchValue-1] = 0;
 310         if( len )
 311             len--;
 312         break;
 313     case MSIFIELD_NULL:
 314         if( *pcchValue > 0 )
 315             szValue[0] = 0;
 316         break;
 317     default:
 318         ret = ERROR_INVALID_PARAMETER;
 319         break;
 320     }
 321
 322     if( *pcchValue < len )
 323         ret = ERROR_MORE_DATA;
 324     *pcchValue = len;
 325
 326     return ret;
 327 }
 328
 329 UINT WINAPI MsiRecordGetStringA(MSIHANDLE handle, unsigned int iField,
 330                LPSTR szValue, DWORD *pcchValue)
 331 {
 332     MSIRECORD *rec;
 333     UINT ret;
 334
 335     TRACE("%ld %d %p %p\n", handle, iField, szValue, pcchValue);
 336
 337     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 338     if( !rec )
 339         return ERROR_INVALID_HANDLE;
 340     msiobj_lock( &rec->hdr );
 341     ret = MSI_RecordGetStringA( rec, iField, szValue, pcchValue);
 342     msiobj_unlock( &rec->hdr );
 343     msiobj_release( &rec->hdr );
 344     return ret;
 345 }
 346
 347 const WCHAR *MSI_RecordGetString( MSIRECORD *rec, unsigned int iField )
 348 {
 349     if( iField > rec->count )
 350         return NULL;
 351
 352     if( rec->fields[iField].type != MSIFIELD_WSTR )
 353         return NULL;
 354
 355     return rec->fields[iField].u.szwVal;
 356 }
 357
 358 UINT MSI_RecordGetStringW(MSIRECORD *rec, unsigned int iField,
 359                LPWSTR szValue, DWORD *pcchValue)
 360 {
 361     UINT len=0, ret;
 362     WCHAR buffer[16];
 363     static const WCHAR szFormat[] = { '%','d',0 };
 364
 365     TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue);
 366
 367     if( iField > rec->count )
 368         return ERROR_INVALID_PARAMETER;
 369
 370     ret = ERROR_SUCCESS;
 371     switch( rec->fields[iField].type )
 372     {
 373     case MSIFIELD_INT:
 374         wsprintfW(buffer, szFormat, rec->fields[iField].u.iVal);
 375         len = lstrlenW( buffer );
 376         lstrcpynW(szValue, buffer, *pcchValue);
 377         break;
 378     case MSIFIELD_WSTR:
 379         len = lstrlenW( rec->fields[iField].u.szwVal );
 380         lstrcpynW(szValue, rec->fields[iField].u.szwVal, *pcchValue);
 381         break;
 382     case MSIFIELD_NULL:
 383         len = 1;
 384         if( *pcchValue > 0 )
 385             szValue[0] = 0;
 386     default:
 387         break;
 388     }
 389
 390     if( *pcchValue < len )
 391         ret = ERROR_MORE_DATA;
 392     *pcchValue = len;
 393
 394     return ret;
 395 }
 396
 397 UINT WINAPI MsiRecordGetStringW(MSIHANDLE handle, unsigned int iField,
 398                LPWSTR szValue, DWORD *pcchValue)
 399 {
 400     MSIRECORD *rec;
 401     UINT ret;
 402
 403     TRACE("%ld %d %p %p\n", handle, iField, szValue, pcchValue);
 404
 405     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 406     if( !rec )
 407         return ERROR_INVALID_HANDLE;
 408
 409     msiobj_lock( &rec->hdr );
 410     ret = MSI_RecordGetStringW( rec, iField, szValue, pcchValue );
 411     msiobj_unlock( &rec->hdr );
 412     msiobj_release( &rec->hdr );
 413     return ret;
 414 }
 415
 416 static UINT msi_get_stream_size( IStream *stm )
 417 {
 418     STATSTG stat;
 419     HRESULT r;
 420
 421     r = IStream_Stat( stm, &stat, STATFLAG_NONAME );
 422     if( FAILED(r) )
 423         return 0;
 424     return stat.cbSize.QuadPart;
 425 }
 426
 427 UINT MSI_RecordDataSize(MSIRECORD *rec, unsigned int iField)
 428 {
 429     TRACE("%p %d\n", rec, iField);
 430
 431     if( iField > rec->count )
 432         return 0;
 433
 434     switch( rec->fields[iField].type )
 435     {
 436     case MSIFIELD_INT:
 437         return sizeof (INT);
 438     case MSIFIELD_WSTR:
 439         return lstrlenW( rec->fields[iField].u.szwVal );
 440     case MSIFIELD_NULL:
 441         break;
 442     case MSIFIELD_STREAM:
 443         return msi_get_stream_size( rec->fields[iField].u.stream );
 444     }
 445     return 0;
 446 }
 447
 448 UINT WINAPI MsiRecordDataSize(MSIHANDLE handle, unsigned int iField)
 449 {
 450     MSIRECORD *rec;
 451     UINT ret;
 452
 453     TRACE("%ld %d\n", handle, iField);
 454
 455     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 456     if( !rec )
 457         return 0;
 458     msiobj_lock( &rec->hdr );
 459     ret = MSI_RecordDataSize( rec, iField);
 460     msiobj_unlock( &rec->hdr );
 461     msiobj_release( &rec->hdr );
 462     return ret;
 463 }
 464
 465 UINT MSI_RecordSetStringA( MSIRECORD *rec, unsigned int iField, LPCSTR szValue )
 466 {
 467     LPWSTR str;
 468
 469     TRACE("%p %d %s\n", rec, iField, debugstr_a(szValue));
 470
 471     if( iField > rec->count )
 472         return ERROR_INVALID_FIELD;
 473
 474     MSI_FreeField( &rec->fields[iField] );
 475     if( szValue && szValue[0] )
 476     {
 477         str = strdupAtoW( szValue );
 478         rec->fields[iField].type = MSIFIELD_WSTR;
 479         rec->fields[iField].u.szwVal = str;
 480     }
 481     else
 482     {
 483         rec->fields[iField].type = MSIFIELD_NULL;
 484         rec->fields[iField].u.szwVal = NULL;
 485     }
 486
 487     return 0;
 488 }
 489
 490 UINT WINAPI MsiRecordSetStringA( MSIHANDLE handle, unsigned int iField, LPCSTR szValue )
 491 {
 492     MSIRECORD *rec;
 493     UINT ret;
 494
 495     TRACE("%ld %d %s\n", handle, iField, debugstr_a(szValue));
 496
 497     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 498     if( !rec )
 499         return ERROR_INVALID_HANDLE;
 500     msiobj_lock( &rec->hdr );
 501     ret = MSI_RecordSetStringA( rec, iField, szValue );
 502     msiobj_unlock( &rec->hdr );
 503     msiobj_release( &rec->hdr );
 504     return ret;
 505 }
 506
 507 UINT MSI_RecordSetStringW( MSIRECORD *rec, unsigned int iField, LPCWSTR szValue )
 508 {
 509     LPWSTR str;
 510
 511     TRACE("%p %d %s\n", rec, iField, debugstr_w(szValue));
 512
 513     if( iField > rec->count )
 514         return ERROR_INVALID_FIELD;
 515
 516     MSI_FreeField( &rec->fields[iField] );
 517
 518     if( szValue && szValue[0] )
 519     {
 520         str = strdupW( szValue );
 521         rec->fields[iField].type = MSIFIELD_WSTR;
 522         rec->fields[iField].u.szwVal = str;
 523     }
 524     else
 525     {
 526         rec->fields[iField].type = MSIFIELD_NULL;
 527         rec->fields[iField].u.szwVal = NULL;
 528     }
 529
 530     return 0;
 531 }
 532
 533 UINT WINAPI MsiRecordSetStringW( MSIHANDLE handle, unsigned int iField, LPCWSTR szValue )
 534 {
 535     MSIRECORD *rec;
 536     UINT ret;
 537
 538     TRACE("%ld %d %s\n", handle, iField, debugstr_w(szValue));
 539
 540     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 541     if( !rec )
 542         return ERROR_INVALID_HANDLE;
 543
 544     msiobj_lock( &rec->hdr );
 545     ret = MSI_RecordSetStringW( rec, iField, szValue );
 546     msiobj_unlock( &rec->hdr );
 547     msiobj_release( &rec->hdr );
 548     return ret;
 549 }
 550
 551 /* read the data in a file into an IStream */
 552 static UINT RECORD_StreamFromFile(LPCWSTR szFile, IStream **pstm)
 553 {
 554     DWORD sz, szHighWord = 0, read;
 555     HANDLE handle;
 556     HGLOBAL hGlob = 0;
 557     HRESULT hr;
 558     ULARGE_INTEGER ulSize;
 559
 560     TRACE("reading %s\n", debugstr_w(szFile));
 561
 562     /* read the file into memory */
 563     handle = CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 564     if( handle == INVALID_HANDLE_VALUE )
 565         return GetLastError();
 566     sz = GetFileSize(handle, &szHighWord);
 567     if( sz != INVALID_FILE_SIZE && szHighWord == 0 )
 568     {
 569         hGlob = GlobalAlloc(GMEM_FIXED, sz);
 570         if( hGlob )
 571         {
 572             BOOL r = ReadFile(handle, hGlob, sz, &read, NULL);
 573             if( !r )
 574             {
 575                 GlobalFree(hGlob);
 576                 hGlob = 0;
 577             }
 578         }
 579     }
 580     CloseHandle(handle);
 581     if( !hGlob )
 582         return ERROR_FUNCTION_FAILED;
 583
 584     /* make a stream out of it, and set the correct file size */
 585     hr = CreateStreamOnHGlobal(hGlob, TRUE, pstm);
 586     if( FAILED( hr ) )
 587     {
 588         GlobalFree(hGlob);
 589         return ERROR_FUNCTION_FAILED;
 590     }
 591
 592     /* set the correct size - CreateStreamOnHGlobal screws it up */
 593     ulSize.QuadPart = sz;
 594     IStream_SetSize(*pstm, ulSize);
 595
 596     TRACE("read %s, %ld bytes into IStream %p\n", debugstr_w(szFile), sz, *pstm);
 597
 598     return ERROR_SUCCESS;
 599 }
 600
 601 UINT MSI_RecordSetStreamW(MSIRECORD *rec, unsigned int iField, LPCWSTR szFilename)
 602 {
 603     IStream *stm = NULL;
 604     HRESULT r;
 605
 606     if( (iField == 0) || (iField > rec->count) )
 607         return ERROR_INVALID_PARAMETER;
 608
 609     /* no filename means we should seek back to the start of the stream */
 610     if( !szFilename )
 611     {
 612         LARGE_INTEGER ofs;
 613         ULARGE_INTEGER cur;
 614
 615         if( rec->fields[iField].type != MSIFIELD_STREAM )
 616             return ERROR_INVALID_FIELD;
 617
 618         stm = rec->fields[iField].u.stream;
 619         if( !stm )
 620             return ERROR_INVALID_FIELD;
 621
 622         ofs.QuadPart = 0;
 623         r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
 624         if( FAILED( r ) )
 625             return ERROR_FUNCTION_FAILED;
 626     }
 627     else
 628     {
 629         /* read the file into a stream and save the stream in the record */
 630         r = RECORD_StreamFromFile(szFilename, &stm);
 631         if( r != ERROR_SUCCESS )
 632             return r;
 633
 634         /* if all's good, store it in the record */
 635         MSI_FreeField( &rec->fields[iField] );
 636         rec->fields[iField].type = MSIFIELD_STREAM;
 637         rec->fields[iField].u.stream = stm;
 638     }
 639
 640     return ERROR_SUCCESS;
 641 }
 642
 643 UINT WINAPI MsiRecordSetStreamA(MSIHANDLE hRecord, unsigned int iField, LPCSTR szFilename)
 644 {
 645     LPWSTR wstr = NULL;
 646     UINT ret;
 647
 648     TRACE("%ld %d %s\n", hRecord, iField, debugstr_a(szFilename));
 649
 650     if( szFilename )
 651     {
 652         wstr = strdupAtoW( szFilename );
 653         if( !wstr )
 654              return ERROR_OUTOFMEMORY;
 655     }
 656     ret = MsiRecordSetStreamW(hRecord, iField, wstr);
 657     HeapFree(GetProcessHeap(),0,wstr);
 658
 659     return ret;
 660 }
 661
 662 UINT WINAPI MsiRecordSetStreamW(MSIHANDLE handle, unsigned int iField, LPCWSTR szFilename)
 663 {
 664     MSIRECORD *rec;
 665     UINT ret;
 666
 667     TRACE("%ld %d %s\n", handle, iField, debugstr_w(szFilename));
 668
 669     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 670     if( !rec )
 671         return ERROR_INVALID_HANDLE;
 672
 673     msiobj_lock( &rec->hdr );
 674     ret = MSI_RecordSetStreamW( rec, iField, szFilename );
 675     msiobj_unlock( &rec->hdr );
 676     msiobj_release( &rec->hdr );
 677     return ret;
 678 }
 679
 680 UINT MSI_RecordReadStream(MSIRECORD *rec, unsigned int iField, char *buf, DWORD *sz)
 681 {
 682     ULONG count;
 683     HRESULT r;
 684     IStream *stm;
 685
 686     TRACE("%p %d %p %p\n", rec, iField, buf, sz);
 687
 688     if( !sz )
 689         return ERROR_INVALID_PARAMETER;
 690
 691     if( iField > rec->count)
 692         return ERROR_INVALID_PARAMETER;
 693
 694     if( rec->fields[iField].type != MSIFIELD_STREAM )
 695         return ERROR_INVALID_DATATYPE;
 696
 697     stm = rec->fields[iField].u.stream;
 698     if( !stm )
 699         return ERROR_INVALID_PARAMETER;
 700
 701     /* if there's no buffer pointer, calculate the length to the end */
 702     if( !buf )
 703     {
 704         LARGE_INTEGER ofs;
 705         ULARGE_INTEGER end, cur;
 706
 707         ofs.QuadPart = cur.QuadPart = 0;
 708         end.QuadPart = 0;
 709         r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
 710         IStream_Seek( stm, ofs, STREAM_SEEK_END, &end );
 711         ofs.QuadPart = cur.QuadPart;
 712         IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
 713         *sz = end.QuadPart - cur.QuadPart;
 714
 715         return ERROR_SUCCESS;
 716     }
 717
 718     /* read the data */
 719     count = 0;
 720     r = IStream_Read( stm, buf, *sz, &count );
 721     if( FAILED( r ) )
 722     {
 723         *sz = 0;
 724         return ERROR_FUNCTION_FAILED;
 725     }
 726
 727     *sz = count;
 728
 729     return ERROR_SUCCESS;
 730 }
 731
 732 UINT WINAPI MsiRecordReadStream(MSIHANDLE handle, unsigned int iField, char *buf, DWORD *sz)
 733 {
 734     MSIRECORD *rec;
 735     UINT ret;
 736
 737     TRACE("%ld %d %p %p\n", handle, iField, buf, sz);
 738
 739     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 740     if( !rec )
 741         return ERROR_INVALID_HANDLE;
 742     msiobj_lock( &rec->hdr );
 743     ret = MSI_RecordReadStream( rec, iField, buf, sz );
 744     msiobj_unlock( &rec->hdr );
 745     msiobj_release( &rec->hdr );
 746     return ret;
 747 }
 748
 749 UINT MSI_RecordSetIStream( MSIRECORD *rec, unsigned int iField, IStream *stm )
 750 {
 751     TRACE("%p %d %p\n", rec, iField, stm);
 752
 753     if( iField > rec->count )
 754         return ERROR_INVALID_FIELD;
 755
 756     MSI_FreeField( &rec->fields[iField] );
 757
 758     rec->fields[iField].type = MSIFIELD_STREAM;
 759     rec->fields[iField].u.stream = stm;
 760     IStream_AddRef( stm );
 761
 762     return ERROR_SUCCESS;
 763 }
 764
 765 UINT MSI_RecordGetIStream( MSIRECORD *rec, unsigned int iField, IStream **pstm)
 766 {
 767     TRACE("%p %d %p\n", rec, iField, pstm);
 768
 769     if( iField > rec->count )
 770         return ERROR_INVALID_FIELD;
 771
 772     if( rec->fields[iField].type != MSIFIELD_STREAM )
 773         return ERROR_INVALID_FIELD;
 774
 775     *pstm = rec->fields[iField].u.stream;
 776     IStream_AddRef( *pstm );
 777
 778     return ERROR_SUCCESS;
 779 }
 780
 781 static UINT msi_dump_stream_to_file( IStream *stm, LPCWSTR name )
 782 {
 783     ULARGE_INTEGER size;
 784     LARGE_INTEGER pos;
 785     IStream *out;
 786     DWORD stgm;
 787     HRESULT r;
 788
 789     stgm = STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE;
 790     r = SHCreateStreamOnFileW( name, stgm, &out );
 791     if( FAILED( r ) )
 792         return ERROR_FUNCTION_FAILED;
 793
 794     pos.QuadPart = 0;
 795     r = IStream_Seek( stm, pos, STREAM_SEEK_END, &size );
 796     if( FAILED( r ) )
 797         goto end;
 798
 799     pos.QuadPart = 0;
 800     r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
 801     if( FAILED( r ) )
 802         goto end;
 803
 804     r = IStream_CopyTo( stm, out, size, NULL, NULL );
 805
 806 end:
 807     IStream_Release( out );
 808     if( FAILED( r ) )
 809         return ERROR_FUNCTION_FAILED;
 810     return ERROR_SUCCESS;
 811 }
 812
 813 UINT MSI_RecordStreamToFile( MSIRECORD *rec, unsigned int iField, LPCWSTR name )
 814 {
 815     IStream *stm = NULL;
 816     UINT r;
 817
 818     TRACE("%p %u %s\n", rec, iField, debugstr_w(name));
 819
 820     msiobj_lock( &rec->hdr );
 821
 822     r = MSI_RecordGetIStream( rec, iField, &stm );
 823     if( r == ERROR_SUCCESS )
 824     {
 825         r = msi_dump_stream_to_file( stm, name );
 826         IStream_Release( stm );
 827     }
 828
 829     msiobj_unlock( &rec->hdr );
 830
 831     return r;
 832 }