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