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