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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 "wine/unicode.h"
  31 #include "msi.h"
  32 #include "msiquery.h"
  33 #include "msipriv.h"
  34 #include "objidl.h"
  35 #include "winnls.h"
  36 #include "ole2.h"
  37
  38 #include "winreg.h"
  39 #include "shlwapi.h"
  40
  41 #include "query.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
  44
  45 #define MSIFIELD_NULL   0
  46 #define MSIFIELD_INT    1
  47 #define MSIFIELD_WSTR   3
  48 #define MSIFIELD_STREAM 4
  49 #define MSIFIELD_INTPTR 5
  50
  51 static void MSI_FreeField( MSIFIELD *field )
  52 {
  53     switch( field->type )
  54     {
  55     case MSIFIELD_NULL:
  56     case MSIFIELD_INT:
  57     case MSIFIELD_INTPTR:
  58         break;
  59     case MSIFIELD_WSTR:
  60         msi_free( field->u.szwVal);
  61         break;
  62     case MSIFIELD_STREAM:
  63         IStream_Release( field->u.stream );
  64         break;
  65     default:
  66         ERR("Invalid field type %d\n", field->type);
  67     }
  68 }
  69
  70 void MSI_CloseRecord( MSIOBJECTHDR *arg )
  71 {
  72     MSIRECORD *rec = (MSIRECORD *) arg;
  73     UINT i;
  74
  75     for( i=0; i<=rec->count; i++ )
  76         MSI_FreeField( &rec->fields[i] );
  77 }
  78
  79 MSIRECORD *MSI_CreateRecord( UINT cParams )
  80 {
  81     MSIRECORD *rec;
  82
  83     TRACE("%d\n", cParams);
  84
  85     if( cParams>65535 )
  86         return NULL;
  87
  88     rec = alloc_msiobject( MSIHANDLETYPE_RECORD, FIELD_OFFSET(MSIRECORD, fields[cParams + 1]),
  89             MSI_CloseRecord );
  90     if( rec )
  91         rec->count = cParams;
  92     return rec;
  93 }
  94
  95 MSIHANDLE WINAPI MsiCreateRecord( UINT cParams )
  96 {
  97     MSIRECORD *rec;
  98     MSIHANDLE ret = 0;
  99
 100     TRACE("%d\n", cParams);
 101
 102     rec = MSI_CreateRecord( cParams );
 103     if( rec )
 104     {
 105         ret = alloc_msihandle( &rec->hdr );
 106         msiobj_release( &rec->hdr );
 107     }
 108     return ret;
 109 }
 110
 111 UINT MSI_RecordGetFieldCount( const MSIRECORD *rec )
 112 {
 113     return rec->count;
 114 }
 115
 116 UINT WINAPI MsiRecordGetFieldCount( MSIHANDLE handle )
 117 {
 118     MSIRECORD *rec;
 119     UINT ret;
 120
 121     TRACE("%d\n", handle );
 122
 123     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 124     if( !rec )
 125         return -1;
 126
 127     msiobj_lock( &rec->hdr );
 128     ret = MSI_RecordGetFieldCount( rec );
 129     msiobj_unlock( &rec->hdr );
 130     msiobj_release( &rec->hdr );
 131
 132     return ret;
 133 }
 134
 135 static BOOL string2intW( LPCWSTR str, int *out )
 136 {
 137     int x = 0;
 138     LPCWSTR p = str;
 139
 140     if( *p == '-' ) /* skip the minus sign */
 141         p++;
 142     while ( *p )
 143     {
 144         if( (*p < '0') || (*p > '9') )
 145             return FALSE;
 146         x *= 10;
 147         x += (*p - '0');
 148         p++;
 149     }
 150
 151     if( str[0] == '-' ) /* check if it's negative */
 152         x = -x;
 153     *out = x;
 154
 155     return TRUE;
 156 }
 157
 158 WCHAR *msi_strdupW( const WCHAR *value, int len )
 159 {
 160     WCHAR *ret;
 161
 162     if (!value) return NULL;
 163     if (!(ret = msi_alloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
 164     memcpy( ret, value, len * sizeof(WCHAR) );
 165     ret[len] = 0;
 166     return ret;
 167 }
 168
 169 UINT MSI_RecordCopyField( MSIRECORD *in_rec, UINT in_n,
 170                           MSIRECORD *out_rec, UINT out_n )
 171 {
 172     UINT r = ERROR_SUCCESS;
 173
 174     msiobj_lock( &in_rec->hdr );
 175
 176     if ( in_n > in_rec->count || out_n > out_rec->count )
 177         r = ERROR_FUNCTION_FAILED;
 178     else if ( in_rec != out_rec || in_n != out_n )
 179     {
 180         LPWSTR str;
 181         MSIFIELD *in, *out;
 182
 183         in = &in_rec->fields[in_n];
 184         out = &out_rec->fields[out_n];
 185
 186         switch ( in->type )
 187         {
 188         case MSIFIELD_NULL:
 189             break;
 190         case MSIFIELD_INT:
 191             out->u.iVal = in->u.iVal;
 192             break;
 193         case MSIFIELD_INTPTR:
 194             out->u.pVal = in->u.pVal;
 195             break;
 196         case MSIFIELD_WSTR:
 197             if ((str = msi_strdupW( in->u.szwVal, in->len )))
 198             {
 199                 out->u.szwVal = str;
 200                 out->len = in->len;
 201             }
 202             else r = ERROR_OUTOFMEMORY;
 203             break;
 204         case MSIFIELD_STREAM:
 205             IStream_AddRef( in->u.stream );
 206             out->u.stream = in->u.stream;
 207             break;
 208         default:
 209             ERR("invalid field type %d\n", in->type);
 210         }
 211         if (r == ERROR_SUCCESS)
 212             out->type = in->type;
 213     }
 214
 215     msiobj_unlock( &in_rec->hdr );
 216     return r;
 217 }
 218
 219 INT_PTR MSI_RecordGetIntPtr( MSIRECORD *rec, UINT iField )
 220 {
 221     int ret;
 222
 223     TRACE( "%p %d\n", rec, iField );
 224
 225     if( iField > rec->count )
 226         return MININT_PTR;
 227
 228     switch( rec->fields[iField].type )
 229     {
 230     case MSIFIELD_INT:
 231         return rec->fields[iField].u.iVal;
 232     case MSIFIELD_INTPTR:
 233         return rec->fields[iField].u.pVal;
 234     case MSIFIELD_WSTR:
 235         if( string2intW( rec->fields[iField].u.szwVal, &ret ) )
 236             return ret;
 237         return MININT_PTR;
 238     default:
 239         break;
 240     }
 241
 242     return MININT_PTR;
 243 }
 244
 245 int MSI_RecordGetInteger( MSIRECORD *rec, UINT iField)
 246 {
 247     int ret = 0;
 248
 249     TRACE("%p %d\n", rec, iField );
 250
 251     if( iField > rec->count )
 252         return MSI_NULL_INTEGER;
 253
 254     switch( rec->fields[iField].type )
 255     {
 256     case MSIFIELD_INT:
 257         return rec->fields[iField].u.iVal;
 258     case MSIFIELD_INTPTR:
 259         return rec->fields[iField].u.pVal;
 260     case MSIFIELD_WSTR:
 261         if( string2intW( rec->fields[iField].u.szwVal, &ret ) )
 262             return ret;
 263         return MSI_NULL_INTEGER;
 264     default:
 265         break;
 266     }
 267
 268     return MSI_NULL_INTEGER;
 269 }
 270
 271 int WINAPI MsiRecordGetInteger( MSIHANDLE handle, UINT iField)
 272 {
 273     MSIRECORD *rec;
 274     UINT ret;
 275
 276     TRACE("%d %d\n", handle, iField );
 277
 278     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 279     if( !rec )
 280         return MSI_NULL_INTEGER;
 281
 282     msiobj_lock( &rec->hdr );
 283     ret = MSI_RecordGetInteger( rec, iField );
 284     msiobj_unlock( &rec->hdr );
 285     msiobj_release( &rec->hdr );
 286
 287     return ret;
 288 }
 289
 290 UINT WINAPI MsiRecordClearData( MSIHANDLE handle )
 291 {
 292     MSIRECORD *rec;
 293     UINT i;
 294
 295     TRACE("%d\n", handle );
 296
 297     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 298     if( !rec )
 299         return ERROR_INVALID_HANDLE;
 300
 301     msiobj_lock( &rec->hdr );
 302     for( i=0; i<=rec->count; i++)
 303     {
 304         MSI_FreeField( &rec->fields[i] );
 305         rec->fields[i].type = MSIFIELD_NULL;
 306         rec->fields[i].u.iVal = 0;
 307     }
 308     msiobj_unlock( &rec->hdr );
 309     msiobj_release( &rec->hdr );
 310
 311     return ERROR_SUCCESS;
 312 }
 313
 314 UINT MSI_RecordSetIntPtr( MSIRECORD *rec, UINT iField, INT_PTR pVal )
 315 {
 316     TRACE("%p %u %ld\n", rec, iField, pVal);
 317
 318     if( iField > rec->count )
 319         return ERROR_INVALID_PARAMETER;
 320
 321     MSI_FreeField( &rec->fields[iField] );
 322     rec->fields[iField].type = MSIFIELD_INTPTR;
 323     rec->fields[iField].u.pVal = pVal;
 324
 325     return ERROR_SUCCESS;
 326 }
 327
 328 UINT MSI_RecordSetInteger( MSIRECORD *rec, UINT iField, int iVal )
 329 {
 330     TRACE("%p %u %d\n", rec, iField, iVal);
 331
 332     if( iField > rec->count )
 333         return ERROR_INVALID_PARAMETER;
 334
 335     MSI_FreeField( &rec->fields[iField] );
 336
 337     if (iVal == MSI_NULL_INTEGER)
 338     {
 339         rec->fields[iField].type = MSIFIELD_NULL;
 340         rec->fields[iField].u.szwVal = NULL;
 341     }
 342     else
 343     {
 344         rec->fields[iField].type = MSIFIELD_INT;
 345         rec->fields[iField].u.iVal = iVal;
 346     }
 347
 348     return ERROR_SUCCESS;
 349 }
 350
 351 UINT WINAPI MsiRecordSetInteger( MSIHANDLE handle, UINT iField, int iVal )
 352 {
 353     MSIRECORD *rec;
 354     UINT ret;
 355
 356     TRACE("%d %u %d\n", handle, iField, iVal);
 357
 358     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 359     if( !rec )
 360         return ERROR_INVALID_HANDLE;
 361
 362     msiobj_lock( &rec->hdr );
 363     ret = MSI_RecordSetInteger( rec, iField, iVal );
 364     msiobj_unlock( &rec->hdr );
 365     msiobj_release( &rec->hdr );
 366     return ret;
 367 }
 368
 369 BOOL MSI_RecordIsNull( MSIRECORD *rec, UINT iField )
 370 {
 371     BOOL r = TRUE;
 372
 373     TRACE("%p %d\n", rec, iField );
 374
 375     r = ( iField > rec->count ) ||
 376         ( rec->fields[iField].type == MSIFIELD_NULL );
 377
 378     return r;
 379 }
 380
 381 BOOL WINAPI MsiRecordIsNull( MSIHANDLE handle, UINT iField )
 382 {
 383     MSIRECORD *rec;
 384     UINT ret;
 385
 386     TRACE("%d %d\n", handle, iField );
 387
 388     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 389     if( !rec )
 390         return FALSE;
 391     msiobj_lock( &rec->hdr );
 392     ret = MSI_RecordIsNull( rec, iField );
 393     msiobj_unlock( &rec->hdr );
 394     msiobj_release( &rec->hdr );
 395     return ret;
 396
 397 }
 398
 399 UINT MSI_RecordGetStringA(MSIRECORD *rec, UINT iField,
 400                LPSTR szValue, LPDWORD pcchValue)
 401 {
 402     UINT len = 0, ret = ERROR_SUCCESS;
 403     CHAR buffer[16];
 404
 405     TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue);
 406
 407     if( iField > rec->count )
 408     {
 409         if ( szValue && *pcchValue > 0 )
 410             szValue[0] = 0;
 411
 412         *pcchValue = 0;
 413         return ERROR_SUCCESS;
 414     }
 415
 416     switch( rec->fields[iField].type )
 417     {
 418     case MSIFIELD_INT:
 419         wsprintfA(buffer, "%d", rec->fields[iField].u.iVal);
 420         len = lstrlenA( buffer );
 421         if (szValue)
 422             lstrcpynA(szValue, buffer, *pcchValue);
 423         break;
 424     case MSIFIELD_WSTR:
 425         len = WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal,
 426                                    rec->fields[iField].len + 1, NULL, 0 , NULL, NULL );
 427         if (szValue)
 428             WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal,
 429                                  rec->fields[iField].len + 1, szValue, *pcchValue, NULL, NULL );
 430         if( szValue && *pcchValue && len>*pcchValue )
 431             szValue[*pcchValue-1] = 0;
 432         if( len )
 433             len--;
 434         break;
 435     case MSIFIELD_NULL:
 436         if( szValue && *pcchValue > 0 )
 437             szValue[0] = 0;
 438         break;
 439     default:
 440         ret = ERROR_INVALID_PARAMETER;
 441         break;
 442     }
 443
 444     if( szValue && *pcchValue <= len )
 445         ret = ERROR_MORE_DATA;
 446     *pcchValue = len;
 447
 448     return ret;
 449 }
 450
 451 UINT WINAPI MsiRecordGetStringA(MSIHANDLE handle, UINT iField,
 452                LPSTR szValue, LPDWORD pcchValue)
 453 {
 454     MSIRECORD *rec;
 455     UINT ret;
 456
 457     TRACE("%d %d %p %p\n", handle, iField, szValue, pcchValue);
 458
 459     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 460     if( !rec )
 461         return ERROR_INVALID_HANDLE;
 462     msiobj_lock( &rec->hdr );
 463     ret = MSI_RecordGetStringA( rec, iField, szValue, pcchValue);
 464     msiobj_unlock( &rec->hdr );
 465     msiobj_release( &rec->hdr );
 466     return ret;
 467 }
 468
 469 const WCHAR *msi_record_get_string( const MSIRECORD *rec, UINT field, int *len )
 470 {
 471     if (field > rec->count)
 472         return NULL;
 473
 474     if (rec->fields[field].type != MSIFIELD_WSTR)
 475         return NULL;
 476
 477     if (len) *len = rec->fields[field].len;
 478
 479     return rec->fields[field].u.szwVal;
 480 }
 481
 482 const WCHAR *MSI_RecordGetString( const MSIRECORD *rec, UINT iField )
 483 {
 484     return msi_record_get_string( rec, iField, NULL );
 485 }
 486
 487 UINT MSI_RecordGetStringW(MSIRECORD *rec, UINT iField,
 488                LPWSTR szValue, LPDWORD pcchValue)
 489 {
 490     static const WCHAR szFormat[] = {'%','d',0};
 491     UINT len = 0, ret = ERROR_SUCCESS;
 492     WCHAR buffer[16];
 493
 494     TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue);
 495
 496     if( iField > rec->count )
 497     {
 498         if ( szValue && *pcchValue > 0 )
 499             szValue[0] = 0;
 500
 501         *pcchValue = 0;
 502         return ERROR_SUCCESS;
 503     }
 504
 505     switch( rec->fields[iField].type )
 506     {
 507     case MSIFIELD_INT:
 508         wsprintfW(buffer, szFormat, rec->fields[iField].u.iVal);
 509         len = lstrlenW( buffer );
 510         if (szValue)
 511             lstrcpynW(szValue, buffer, *pcchValue);
 512         break;
 513     case MSIFIELD_WSTR:
 514         len = rec->fields[iField].len;
 515         if (szValue)
 516             memcpy( szValue, rec->fields[iField].u.szwVal, min(len + 1, *pcchValue) * sizeof(WCHAR) );
 517         break;
 518     case MSIFIELD_NULL:
 519         if( szValue && *pcchValue > 0 )
 520             szValue[0] = 0;
 521         break;
 522     default:
 523         break;
 524     }
 525
 526     if( szValue && *pcchValue <= len )
 527         ret = ERROR_MORE_DATA;
 528     *pcchValue = len;
 529
 530     return ret;
 531 }
 532
 533 UINT WINAPI MsiRecordGetStringW(MSIHANDLE handle, UINT iField,
 534                LPWSTR szValue, LPDWORD pcchValue)
 535 {
 536     MSIRECORD *rec;
 537     UINT ret;
 538
 539     TRACE("%d %d %p %p\n", handle, iField, szValue, pcchValue);
 540
 541     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 542     if( !rec )
 543         return ERROR_INVALID_HANDLE;
 544
 545     msiobj_lock( &rec->hdr );
 546     ret = MSI_RecordGetStringW( rec, iField, szValue, pcchValue );
 547     msiobj_unlock( &rec->hdr );
 548     msiobj_release( &rec->hdr );
 549     return ret;
 550 }
 551
 552 static UINT msi_get_stream_size( IStream *stm )
 553 {
 554     STATSTG stat;
 555     HRESULT r;
 556
 557     r = IStream_Stat( stm, &stat, STATFLAG_NONAME );
 558     if( FAILED(r) )
 559         return 0;
 560     return stat.cbSize.QuadPart;
 561 }
 562
 563 static UINT MSI_RecordDataSize(MSIRECORD *rec, UINT iField)
 564 {
 565     TRACE("%p %d\n", rec, iField);
 566
 567     if( iField > rec->count )
 568         return 0;
 569
 570     switch( rec->fields[iField].type )
 571     {
 572     case MSIFIELD_INT:
 573         return sizeof (INT);
 574     case MSIFIELD_WSTR:
 575         return rec->fields[iField].len;
 576     case MSIFIELD_NULL:
 577         break;
 578     case MSIFIELD_STREAM:
 579         return msi_get_stream_size( rec->fields[iField].u.stream );
 580     }
 581     return 0;
 582 }
 583
 584 UINT WINAPI MsiRecordDataSize(MSIHANDLE handle, UINT iField)
 585 {
 586     MSIRECORD *rec;
 587     UINT ret;
 588
 589     TRACE("%d %d\n", handle, iField);
 590
 591     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 592     if( !rec )
 593         return 0;
 594     msiobj_lock( &rec->hdr );
 595     ret = MSI_RecordDataSize( rec, iField);
 596     msiobj_unlock( &rec->hdr );
 597     msiobj_release( &rec->hdr );
 598     return ret;
 599 }
 600
 601 UINT WINAPI MsiRecordSetStringA( MSIHANDLE handle, UINT iField, LPCSTR szValue )
 602 {
 603     WCHAR *valueW = NULL;
 604     MSIRECORD *rec;
 605     UINT ret;
 606
 607     TRACE("%d %d %s\n", handle, iField, debugstr_a(szValue));
 608
 609     if (szValue && !(valueW = strdupAtoW( szValue ))) return ERROR_OUTOFMEMORY;
 610
 611     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 612     if( !rec )
 613     {
 614         msi_free( valueW );
 615         return ERROR_INVALID_HANDLE;
 616     }
 617     msiobj_lock( &rec->hdr );
 618     ret = MSI_RecordSetStringW( rec, iField, valueW );
 619     msiobj_unlock( &rec->hdr );
 620     msiobj_release( &rec->hdr );
 621     msi_free( valueW );
 622     return ret;
 623 }
 624
 625 UINT msi_record_set_string( MSIRECORD *rec, UINT field, const WCHAR *value, int len )
 626 {
 627     if (field > rec->count)
 628         return ERROR_INVALID_FIELD;
 629
 630     MSI_FreeField( &rec->fields[field] );
 631
 632     if (value && len < 0) len = strlenW( value );
 633
 634     if (value && len)
 635     {
 636         rec->fields[field].type = MSIFIELD_WSTR;
 637         rec->fields[field].u.szwVal = msi_strdupW( value, len );
 638         rec->fields[field].len = len;
 639     }
 640     else
 641     {
 642         rec->fields[field].type = MSIFIELD_NULL;
 643         rec->fields[field].u.szwVal = NULL;
 644         rec->fields[field].len = 0;
 645     }
 646     return 0;
 647 }
 648
 649 UINT MSI_RecordSetStringW( MSIRECORD *rec, UINT iField, LPCWSTR szValue )
 650 {
 651     TRACE("%p %d %s\n", rec, iField, debugstr_w(szValue));
 652
 653     return msi_record_set_string( rec, iField, szValue, -1 );
 654 }
 655
 656 UINT WINAPI MsiRecordSetStringW( MSIHANDLE handle, UINT iField, LPCWSTR szValue )
 657 {
 658     MSIRECORD *rec;
 659     UINT ret;
 660
 661     TRACE("%d %d %s\n", handle, iField, debugstr_w(szValue));
 662
 663     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 664     if( !rec )
 665         return ERROR_INVALID_HANDLE;
 666
 667     msiobj_lock( &rec->hdr );
 668     ret = MSI_RecordSetStringW( rec, iField, szValue );
 669     msiobj_unlock( &rec->hdr );
 670     msiobj_release( &rec->hdr );
 671     return ret;
 672 }
 673
 674 /* read the data in a file into an IStream */
 675 static UINT RECORD_StreamFromFile(LPCWSTR szFile, IStream **pstm)
 676 {
 677     DWORD sz, szHighWord = 0, read;
 678     HANDLE handle;
 679     HGLOBAL hGlob = 0;
 680     HRESULT hr;
 681     ULARGE_INTEGER ulSize;
 682
 683     TRACE("reading %s\n", debugstr_w(szFile));
 684
 685     /* read the file into memory */
 686     handle = CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 687     if( handle == INVALID_HANDLE_VALUE )
 688         return GetLastError();
 689     sz = GetFileSize(handle, &szHighWord);
 690     if( sz != INVALID_FILE_SIZE && szHighWord == 0 )
 691     {
 692         hGlob = GlobalAlloc(GMEM_FIXED, sz);
 693         if( hGlob )
 694         {
 695             BOOL r = ReadFile(handle, hGlob, sz, &read, NULL) && read == sz;
 696             if( !r )
 697             {
 698                 GlobalFree(hGlob);
 699                 hGlob = 0;
 700             }
 701         }
 702     }
 703     CloseHandle(handle);
 704     if( !hGlob )
 705         return ERROR_FUNCTION_FAILED;
 706
 707     /* make a stream out of it, and set the correct file size */
 708     hr = CreateStreamOnHGlobal(hGlob, TRUE, pstm);
 709     if( FAILED( hr ) )
 710     {
 711         GlobalFree(hGlob);
 712         return ERROR_FUNCTION_FAILED;
 713     }
 714
 715     /* set the correct size - CreateStreamOnHGlobal screws it up */
 716     ulSize.QuadPart = sz;
 717     IStream_SetSize(*pstm, ulSize);
 718
 719     TRACE("read %s, %d bytes into IStream %p\n", debugstr_w(szFile), sz, *pstm);
 720
 721     return ERROR_SUCCESS;
 722 }
 723
 724 UINT MSI_RecordSetStream(MSIRECORD *rec, UINT iField, IStream *stream)
 725 {
 726     if ( (iField == 0) || (iField > rec->count) )
 727         return ERROR_INVALID_PARAMETER;
 728
 729     MSI_FreeField( &rec->fields[iField] );
 730     rec->fields[iField].type = MSIFIELD_STREAM;
 731     rec->fields[iField].u.stream = stream;
 732
 733     return ERROR_SUCCESS;
 734 }
 735
 736 UINT MSI_RecordSetStreamFromFileW(MSIRECORD *rec, UINT iField, LPCWSTR szFilename)
 737 {
 738     IStream *stm = NULL;
 739     HRESULT hr;
 740     UINT ret;
 741
 742     if( (iField == 0) || (iField > rec->count) )
 743         return ERROR_INVALID_PARAMETER;
 744
 745     /* no filename means we should seek back to the start of the stream */
 746     if( !szFilename )
 747     {
 748         LARGE_INTEGER ofs;
 749         ULARGE_INTEGER cur;
 750
 751         if( rec->fields[iField].type != MSIFIELD_STREAM )
 752             return ERROR_INVALID_FIELD;
 753
 754         stm = rec->fields[iField].u.stream;
 755         if( !stm )
 756             return ERROR_INVALID_FIELD;
 757
 758         ofs.QuadPart = 0;
 759         hr = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
 760         if (FAILED( hr ))
 761             return ERROR_FUNCTION_FAILED;
 762     }
 763     else
 764     {
 765         /* read the file into a stream and save the stream in the record */
 766         ret = RECORD_StreamFromFile(szFilename, &stm);
 767         if (ret != ERROR_SUCCESS)
 768             return ret;
 769
 770         /* if all's good, store it in the record */
 771         MSI_RecordSetStream(rec, iField, stm);
 772     }
 773
 774     return ERROR_SUCCESS;
 775 }
 776
 777 UINT WINAPI MsiRecordSetStreamA(MSIHANDLE hRecord, UINT iField, LPCSTR szFilename)
 778 {
 779     LPWSTR wstr = NULL;
 780     UINT ret;
 781
 782     TRACE("%d %d %s\n", hRecord, iField, debugstr_a(szFilename));
 783
 784     if( szFilename )
 785     {
 786         wstr = strdupAtoW( szFilename );
 787         if( !wstr )
 788              return ERROR_OUTOFMEMORY;
 789     }
 790     ret = MsiRecordSetStreamW(hRecord, iField, wstr);
 791     msi_free(wstr);
 792
 793     return ret;
 794 }
 795
 796 UINT WINAPI MsiRecordSetStreamW(MSIHANDLE handle, UINT iField, LPCWSTR szFilename)
 797 {
 798     MSIRECORD *rec;
 799     UINT ret;
 800
 801     TRACE("%d %d %s\n", handle, iField, debugstr_w(szFilename));
 802
 803     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 804     if( !rec )
 805         return ERROR_INVALID_HANDLE;
 806
 807     msiobj_lock( &rec->hdr );
 808     ret = MSI_RecordSetStreamFromFileW( rec, iField, szFilename );
 809     msiobj_unlock( &rec->hdr );
 810     msiobj_release( &rec->hdr );
 811     return ret;
 812 }
 813
 814 UINT MSI_RecordReadStream(MSIRECORD *rec, UINT iField, char *buf, LPDWORD sz)
 815 {
 816     ULONG count;
 817     HRESULT r;
 818     IStream *stm;
 819
 820     TRACE("%p %d %p %p\n", rec, iField, buf, sz);
 821
 822     if( !sz )
 823         return ERROR_INVALID_PARAMETER;
 824
 825     if( iField > rec->count)
 826         return ERROR_INVALID_PARAMETER;
 827
 828     if ( rec->fields[iField].type == MSIFIELD_NULL )
 829     {
 830         *sz = 0;
 831         return ERROR_INVALID_DATA;
 832     }
 833
 834     if( rec->fields[iField].type != MSIFIELD_STREAM )
 835         return ERROR_INVALID_DATATYPE;
 836
 837     stm = rec->fields[iField].u.stream;
 838     if( !stm )
 839         return ERROR_INVALID_PARAMETER;
 840
 841     /* if there's no buffer pointer, calculate the length to the end */
 842     if( !buf )
 843     {
 844         LARGE_INTEGER ofs;
 845         ULARGE_INTEGER end, cur;
 846
 847         ofs.QuadPart = cur.QuadPart = 0;
 848         end.QuadPart = 0;
 849         IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
 850         IStream_Seek( stm, ofs, STREAM_SEEK_END, &end );
 851         ofs.QuadPart = cur.QuadPart;
 852         IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
 853         *sz = end.QuadPart - cur.QuadPart;
 854
 855         return ERROR_SUCCESS;
 856     }
 857
 858     /* read the data */
 859     count = 0;
 860     r = IStream_Read( stm, buf, *sz, &count );
 861     if( FAILED( r ) )
 862     {
 863         *sz = 0;
 864         return ERROR_FUNCTION_FAILED;
 865     }
 866
 867     *sz = count;
 868
 869     return ERROR_SUCCESS;
 870 }
 871
 872 UINT WINAPI MsiRecordReadStream(MSIHANDLE handle, UINT iField, char *buf, LPDWORD sz)
 873 {
 874     MSIRECORD *rec;
 875     UINT ret;
 876
 877     TRACE("%d %d %p %p\n", handle, iField, buf, sz);
 878
 879     rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
 880     if( !rec )
 881         return ERROR_INVALID_HANDLE;
 882     msiobj_lock( &rec->hdr );
 883     ret = MSI_RecordReadStream( rec, iField, buf, sz );
 884     msiobj_unlock( &rec->hdr );
 885     msiobj_release( &rec->hdr );
 886     return ret;
 887 }
 888
 889 UINT MSI_RecordSetIStream( MSIRECORD *rec, UINT iField, IStream *stm )
 890 {
 891     TRACE("%p %d %p\n", rec, iField, stm);
 892
 893     if( iField > rec->count )
 894         return ERROR_INVALID_FIELD;
 895
 896     MSI_FreeField( &rec->fields[iField] );
 897
 898     rec->fields[iField].type = MSIFIELD_STREAM;
 899     rec->fields[iField].u.stream = stm;
 900     IStream_AddRef( stm );
 901
 902     return ERROR_SUCCESS;
 903 }
 904
 905 UINT MSI_RecordGetIStream( MSIRECORD *rec, UINT iField, IStream **pstm)
 906 {
 907     TRACE("%p %d %p\n", rec, iField, pstm);
 908
 909     if( iField > rec->count )
 910         return ERROR_INVALID_FIELD;
 911
 912     if( rec->fields[iField].type != MSIFIELD_STREAM )
 913         return ERROR_INVALID_FIELD;
 914
 915     *pstm = rec->fields[iField].u.stream;
 916     IStream_AddRef( *pstm );
 917
 918     return ERROR_SUCCESS;
 919 }
 920
 921 static UINT msi_dump_stream_to_file( IStream *stm, LPCWSTR name )
 922 {
 923     ULARGE_INTEGER size;
 924     LARGE_INTEGER pos;
 925     IStream *out;
 926     DWORD stgm;
 927     HRESULT r;
 928
 929     stgm = STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE;
 930     r = SHCreateStreamOnFileW( name, stgm, &out );
 931     if( FAILED( r ) )
 932         return ERROR_FUNCTION_FAILED;
 933
 934     pos.QuadPart = 0;
 935     r = IStream_Seek( stm, pos, STREAM_SEEK_END, &size );
 936     if( FAILED( r ) )
 937         goto end;
 938
 939     pos.QuadPart = 0;
 940     r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
 941     if( FAILED( r ) )
 942         goto end;
 943
 944     r = IStream_CopyTo( stm, out, size, NULL, NULL );
 945
 946 end:
 947     IStream_Release( out );
 948     if( FAILED( r ) )
 949         return ERROR_FUNCTION_FAILED;
 950     return ERROR_SUCCESS;
 951 }
 952
 953 UINT MSI_RecordStreamToFile( MSIRECORD *rec, UINT iField, LPCWSTR name )
 954 {
 955     IStream *stm = NULL;
 956     UINT r;
 957
 958     TRACE("%p %u %s\n", rec, iField, debugstr_w(name));
 959
 960     msiobj_lock( &rec->hdr );
 961
 962     r = MSI_RecordGetIStream( rec, iField, &stm );
 963     if( r == ERROR_SUCCESS )
 964     {
 965         r = msi_dump_stream_to_file( stm, name );
 966         IStream_Release( stm );
 967     }
 968
 969     msiobj_unlock( &rec->hdr );
 970
 971     return r;
 972 }
 973
 974 MSIRECORD *MSI_CloneRecord(MSIRECORD *rec)
 975 {
 976     MSIRECORD *clone;
 977     UINT r, i, count;
 978
 979     count = MSI_RecordGetFieldCount(rec);
 980     clone = MSI_CreateRecord(count);
 981     if (!clone)
 982         return NULL;
 983
 984     for (i = 0; i <= count; i++)
 985     {
 986         if (rec->fields[i].type == MSIFIELD_STREAM)
 987         {
 988             if (FAILED(IStream_Clone(rec->fields[i].u.stream,
 989                                      &clone->fields[i].u.stream)))
 990             {
 991                 msiobj_release(&clone->hdr);
 992                 return NULL;
 993             }
 994             clone->fields[i].type = MSIFIELD_STREAM;
 995         }
 996         else
 997         {
 998             r = MSI_RecordCopyField(rec, i, clone, i);
 999             if (r != ERROR_SUCCESS)
1000             {
1001                 msiobj_release(&clone->hdr);
1002                 return NULL;
1003             }
1004         }
1005     }
1006
1007     return clone;
1008 }
1009
1010 BOOL MSI_RecordsAreFieldsEqual(MSIRECORD *a, MSIRECORD *b, UINT field)
1011 {
1012     if (a->fields[field].type != b->fields[field].type)
1013         return FALSE;
1014
1015     switch (a->fields[field].type)
1016     {
1017         case MSIFIELD_NULL:
1018             break;
1019
1020         case MSIFIELD_INT:
1021             if (a->fields[field].u.iVal != b->fields[field].u.iVal)
1022                 return FALSE;
1023             break;
1024
1025         case MSIFIELD_WSTR:
1026             if (a->fields[field].len != b->fields[field].len) return FALSE;
1027             if (memcmp( a->fields[field].u.szwVal, b->fields[field].u.szwVal,
1028                         a->fields[field].len * sizeof(WCHAR) )) return FALSE;
1029             break;
1030
1031         case MSIFIELD_STREAM:
1032         default:
1033             return FALSE;
1034     }
1035     return TRUE;
1036 }
1037
1038
1039 BOOL MSI_RecordsAreEqual(MSIRECORD *a, MSIRECORD *b)
1040 {
1041     UINT i;
1042
1043     if (a->count != b->count)
1044         return FALSE;
1045
1046     for (i = 0; i <= a->count; i++)
1047     {
1048         if (!MSI_RecordsAreFieldsEqual( a, b, i ))
1049             return FALSE;
1050     }
1051
1052     return TRUE;
1053 }
1054
1055 WCHAR *msi_dup_record_field( MSIRECORD *rec, INT field )
1056 {
1057     DWORD sz = 0;
1058     WCHAR *str;
1059     UINT r;
1060
1061     if (MSI_RecordIsNull( rec, field )) return NULL;
1062
1063     r = MSI_RecordGetStringW( rec, field, NULL, &sz );
1064     if (r != ERROR_SUCCESS)
1065         return NULL;
1066
1067     sz++;
1068     str = msi_alloc( sz * sizeof(WCHAR) );
1069     if (!str) return NULL;
1070     str[0] = 0;
1071     r = MSI_RecordGetStringW( rec, field, str, &sz );
1072     if (r != ERROR_SUCCESS)
1073     {
1074         ERR("failed to get string!\n");
1075         msi_free( str );
1076         return NULL;
1077     }
1078     return str;
1079 }
1080
1081 void dump_record(MSIRECORD *rec)
1082 {
1083     int i;
1084     if (!rec)
1085     {
1086         TRACE("(null)\n");
1087         return;
1088     }
1089
1090     TRACE("[");
1091     for (i = 0; i <= rec->count; i++)
1092     {
1093         switch(rec->fields[i].type)
1094         {
1095         case MSIFIELD_NULL: TRACE("(null)"); break;
1096         case MSIFIELD_INT: TRACE("%d", rec->fields[i].u.iVal); break;
1097         case MSIFIELD_WSTR: TRACE("%s", debugstr_w(rec->fields[i].u.szwVal)); break;
1098         case MSIFIELD_INTPTR: TRACE("%ld", rec->fields[i].u.pVal); break;
1099         case MSIFIELD_STREAM: TRACE("%p", rec->fields[i].u.stream); break;
1100         }
1101         if (i < rec->count) TRACE(", ");
1102     }
1103     TRACE("]\n");
1104 }