push 818f085f73990f577927aeb76c81fa65ee9c5568
[wine/hacks.git] / dlls / msi / record.c
blobb02fcd10b9a64ec565b9244369a295bc57e5d906
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
4 * Copyright 2002-2004 Mike McCormack for CodeWeavers
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.
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.
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
21 #include <stdarg.h>
23 #define COBJMACROS
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"
37 #include "winreg.h"
38 #include "shlwapi.h"
40 #include "query.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
44 #define MSIFIELD_NULL 0
45 #define MSIFIELD_INT 1
46 #define MSIFIELD_WSTR 3
47 #define MSIFIELD_STREAM 4
49 static void MSI_FreeField( MSIFIELD *field )
51 switch( field->type )
53 case MSIFIELD_NULL:
54 case MSIFIELD_INT:
55 break;
56 case MSIFIELD_WSTR:
57 msi_free( field->u.szwVal);
58 break;
59 case MSIFIELD_STREAM:
60 IStream_Release( field->u.stream );
61 break;
62 default:
63 ERR("Invalid field type %d\n", field->type);
67 static void MSI_CloseRecord( MSIOBJECTHDR *arg )
69 MSIRECORD *rec = (MSIRECORD *) arg;
70 UINT i;
72 for( i=0; i<=rec->count; i++ )
73 MSI_FreeField( &rec->fields[i] );
76 MSIRECORD *MSI_CreateRecord( UINT cParams )
78 MSIRECORD *rec;
79 UINT len;
81 TRACE("%d\n", cParams);
83 if( cParams>65535 )
84 return NULL;
86 len = sizeof (MSIRECORD) + sizeof (MSIFIELD)*cParams;
87 rec = alloc_msiobject( MSIHANDLETYPE_RECORD, len, MSI_CloseRecord );
88 if( rec )
89 rec->count = cParams;
90 return rec;
93 MSIHANDLE WINAPI MsiCreateRecord( UINT cParams )
95 MSIRECORD *rec;
96 MSIHANDLE ret = 0;
98 TRACE("%d\n", cParams);
100 rec = MSI_CreateRecord( cParams );
101 if( rec )
103 ret = alloc_msihandle( &rec->hdr );
104 msiobj_release( &rec->hdr );
106 return ret;
109 UINT MSI_RecordGetFieldCount( const MSIRECORD *rec )
111 return rec->count;
114 UINT WINAPI MsiRecordGetFieldCount( MSIHANDLE handle )
116 MSIRECORD *rec;
117 UINT ret;
119 TRACE("%ld\n", handle );
121 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
122 if( !rec )
123 return -1;
125 msiobj_lock( &rec->hdr );
126 ret = MSI_RecordGetFieldCount( rec );
127 msiobj_unlock( &rec->hdr );
128 msiobj_release( &rec->hdr );
130 return ret;
133 static BOOL string2intW( LPCWSTR str, int *out )
135 int x = 0;
136 LPCWSTR p = str;
138 if( *p == '-' ) /* skip the minus sign */
139 p++;
140 while ( *p )
142 if( (*p < '0') || (*p > '9') )
143 return FALSE;
144 x *= 10;
145 x += (*p - '0');
146 p++;
149 if( str[0] == '-' ) /* check if it's negative */
150 x = -x;
151 *out = x;
153 return TRUE;
156 UINT MSI_RecordCopyField( MSIRECORD *in_rec, UINT in_n,
157 MSIRECORD *out_rec, UINT out_n )
159 UINT r = ERROR_SUCCESS;
161 msiobj_lock( &in_rec->hdr );
163 if ( in_n > in_rec->count || out_n > out_rec->count )
164 r = ERROR_FUNCTION_FAILED;
165 else if ( in_rec != out_rec || in_n != out_n )
167 LPWSTR str;
168 MSIFIELD *in, *out;
170 in = &in_rec->fields[in_n];
171 out = &out_rec->fields[out_n];
173 switch ( in->type )
175 case MSIFIELD_NULL:
176 break;
177 case MSIFIELD_INT:
178 out->u.iVal = in->u.iVal;
179 break;
180 case MSIFIELD_WSTR:
181 str = strdupW( in->u.szwVal );
182 if ( !str )
183 r = ERROR_OUTOFMEMORY;
184 else
185 out->u.szwVal = str;
186 break;
187 case MSIFIELD_STREAM:
188 IStream_AddRef( in->u.stream );
189 out->u.stream = in->u.stream;
190 break;
191 default:
192 ERR("invalid field type %d\n", in->type);
194 if (r == ERROR_SUCCESS)
195 out->type = in->type;
198 msiobj_unlock( &in_rec->hdr );
200 return r;
203 int MSI_RecordGetInteger( MSIRECORD *rec, UINT iField)
205 int ret = 0;
207 TRACE("%p %d\n", rec, iField );
209 if( iField > rec->count )
210 return MSI_NULL_INTEGER;
212 switch( rec->fields[iField].type )
214 case MSIFIELD_INT:
215 return rec->fields[iField].u.iVal;
216 case MSIFIELD_WSTR:
217 if( string2intW( rec->fields[iField].u.szwVal, &ret ) )
218 return ret;
219 return MSI_NULL_INTEGER;
220 default:
221 break;
224 return MSI_NULL_INTEGER;
227 int WINAPI MsiRecordGetInteger( MSIHANDLE handle, UINT iField)
229 MSIRECORD *rec;
230 UINT ret;
232 TRACE("%ld %d\n", handle, iField );
234 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
235 if( !rec )
236 return MSI_NULL_INTEGER;
238 msiobj_lock( &rec->hdr );
239 ret = MSI_RecordGetInteger( rec, iField );
240 msiobj_unlock( &rec->hdr );
241 msiobj_release( &rec->hdr );
243 return ret;
246 UINT WINAPI MsiRecordClearData( MSIHANDLE handle )
248 MSIRECORD *rec;
249 UINT i;
251 TRACE("%ld\n", handle );
253 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
254 if( !rec )
255 return ERROR_INVALID_HANDLE;
257 msiobj_lock( &rec->hdr );
258 for( i=0; i<=rec->count; i++)
260 MSI_FreeField( &rec->fields[i] );
261 rec->fields[i].type = MSIFIELD_NULL;
262 rec->fields[i].u.iVal = 0;
264 msiobj_unlock( &rec->hdr );
265 msiobj_release( &rec->hdr );
267 return ERROR_SUCCESS;
270 UINT MSI_RecordSetInteger( MSIRECORD *rec, UINT iField, int iVal )
272 TRACE("%p %u %d\n", rec, iField, iVal);
274 if( iField > rec->count )
275 return ERROR_INVALID_PARAMETER;
277 MSI_FreeField( &rec->fields[iField] );
278 rec->fields[iField].type = MSIFIELD_INT;
279 rec->fields[iField].u.iVal = iVal;
281 return ERROR_SUCCESS;
284 UINT WINAPI MsiRecordSetInteger( MSIHANDLE handle, UINT iField, int iVal )
286 MSIRECORD *rec;
287 UINT ret;
289 TRACE("%ld %u %d\n", handle, iField, iVal);
291 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
292 if( !rec )
293 return ERROR_INVALID_HANDLE;
295 msiobj_lock( &rec->hdr );
296 ret = MSI_RecordSetInteger( rec, iField, iVal );
297 msiobj_unlock( &rec->hdr );
298 msiobj_release( &rec->hdr );
299 return ret;
302 BOOL MSI_RecordIsNull( MSIRECORD *rec, UINT iField )
304 BOOL r = TRUE;
306 TRACE("%p %d\n", rec, iField );
308 r = ( iField > rec->count ) ||
309 ( rec->fields[iField].type == MSIFIELD_NULL );
311 return r;
314 BOOL WINAPI MsiRecordIsNull( MSIHANDLE handle, UINT iField )
316 MSIRECORD *rec;
317 UINT ret;
319 TRACE("%ld %d\n", handle, iField );
321 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
322 if( !rec )
323 return 0;
324 msiobj_lock( &rec->hdr );
325 ret = MSI_RecordIsNull( rec, iField );
326 msiobj_unlock( &rec->hdr );
327 msiobj_release( &rec->hdr );
328 return ret;
332 UINT MSI_RecordGetStringA(MSIRECORD *rec, UINT iField,
333 LPSTR szValue, LPDWORD pcchValue)
335 UINT len=0, ret;
336 CHAR buffer[16];
338 TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue);
340 if( iField > rec->count )
342 if ( szValue && *pcchValue > 0 )
343 szValue[0] = 0;
345 *pcchValue = 0;
346 return ERROR_SUCCESS;
349 ret = ERROR_SUCCESS;
350 switch( rec->fields[iField].type )
352 case MSIFIELD_INT:
353 wsprintfA(buffer, "%d", rec->fields[iField].u.iVal);
354 len = lstrlenA( buffer );
355 if (szValue)
356 lstrcpynA(szValue, buffer, *pcchValue);
357 break;
358 case MSIFIELD_WSTR:
359 len = WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal, -1,
360 NULL, 0 , NULL, NULL);
361 if (szValue)
362 WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal, -1,
363 szValue, *pcchValue, NULL, NULL);
364 if( szValue && *pcchValue && len>*pcchValue )
365 szValue[*pcchValue-1] = 0;
366 if( len )
367 len--;
368 break;
369 case MSIFIELD_NULL:
370 if( szValue && *pcchValue > 0 )
371 szValue[0] = 0;
372 break;
373 default:
374 ret = ERROR_INVALID_PARAMETER;
375 break;
378 if( szValue && *pcchValue <= len )
379 ret = ERROR_MORE_DATA;
380 *pcchValue = len;
382 return ret;
385 UINT WINAPI MsiRecordGetStringA(MSIHANDLE handle, UINT iField,
386 LPSTR szValue, LPDWORD pcchValue)
388 MSIRECORD *rec;
389 UINT ret;
391 TRACE("%ld %d %p %p\n", handle, iField, szValue, pcchValue);
393 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
394 if( !rec )
395 return ERROR_INVALID_HANDLE;
396 msiobj_lock( &rec->hdr );
397 ret = MSI_RecordGetStringA( rec, iField, szValue, pcchValue);
398 msiobj_unlock( &rec->hdr );
399 msiobj_release( &rec->hdr );
400 return ret;
403 const WCHAR *MSI_RecordGetString( const MSIRECORD *rec, UINT iField )
405 if( iField > rec->count )
406 return NULL;
408 if( rec->fields[iField].type != MSIFIELD_WSTR )
409 return NULL;
411 return rec->fields[iField].u.szwVal;
414 UINT MSI_RecordGetStringW(MSIRECORD *rec, UINT iField,
415 LPWSTR szValue, LPDWORD pcchValue)
417 UINT len=0, ret;
418 WCHAR buffer[16];
419 static const WCHAR szFormat[] = { '%','d',0 };
421 TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue);
423 if( iField > rec->count )
425 if ( szValue && *pcchValue > 0 )
426 szValue[0] = 0;
428 *pcchValue = 0;
429 return ERROR_SUCCESS;
432 ret = ERROR_SUCCESS;
433 switch( rec->fields[iField].type )
435 case MSIFIELD_INT:
436 wsprintfW(buffer, szFormat, rec->fields[iField].u.iVal);
437 len = lstrlenW( buffer );
438 if (szValue)
439 lstrcpynW(szValue, buffer, *pcchValue);
440 break;
441 case MSIFIELD_WSTR:
442 len = lstrlenW( rec->fields[iField].u.szwVal );
443 if (szValue)
444 lstrcpynW(szValue, rec->fields[iField].u.szwVal, *pcchValue);
445 break;
446 case MSIFIELD_NULL:
447 len = 1;
448 if( szValue && *pcchValue > 0 )
449 szValue[0] = 0;
450 default:
451 break;
454 if( szValue && *pcchValue <= len )
455 ret = ERROR_MORE_DATA;
456 *pcchValue = len;
458 return ret;
461 UINT WINAPI MsiRecordGetStringW(MSIHANDLE handle, UINT iField,
462 LPWSTR szValue, LPDWORD pcchValue)
464 MSIRECORD *rec;
465 UINT ret;
467 TRACE("%ld %d %p %p\n", handle, iField, szValue, pcchValue);
469 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
470 if( !rec )
471 return ERROR_INVALID_HANDLE;
473 msiobj_lock( &rec->hdr );
474 ret = MSI_RecordGetStringW( rec, iField, szValue, pcchValue );
475 msiobj_unlock( &rec->hdr );
476 msiobj_release( &rec->hdr );
477 return ret;
480 static UINT msi_get_stream_size( IStream *stm )
482 STATSTG stat;
483 HRESULT r;
485 r = IStream_Stat( stm, &stat, STATFLAG_NONAME );
486 if( FAILED(r) )
487 return 0;
488 return stat.cbSize.QuadPart;
491 UINT MSI_RecordDataSize(MSIRECORD *rec, UINT iField)
493 TRACE("%p %d\n", rec, iField);
495 if( iField > rec->count )
496 return 0;
498 switch( rec->fields[iField].type )
500 case MSIFIELD_INT:
501 return sizeof (INT);
502 case MSIFIELD_WSTR:
503 return lstrlenW( rec->fields[iField].u.szwVal );
504 case MSIFIELD_NULL:
505 break;
506 case MSIFIELD_STREAM:
507 return msi_get_stream_size( rec->fields[iField].u.stream );
509 return 0;
512 UINT WINAPI MsiRecordDataSize(MSIHANDLE handle, UINT iField)
514 MSIRECORD *rec;
515 UINT ret;
517 TRACE("%ld %d\n", handle, iField);
519 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
520 if( !rec )
521 return 0;
522 msiobj_lock( &rec->hdr );
523 ret = MSI_RecordDataSize( rec, iField);
524 msiobj_unlock( &rec->hdr );
525 msiobj_release( &rec->hdr );
526 return ret;
529 UINT MSI_RecordSetStringA( MSIRECORD *rec, UINT iField, LPCSTR szValue )
531 LPWSTR str;
533 TRACE("%p %d %s\n", rec, iField, debugstr_a(szValue));
535 if( iField > rec->count )
536 return ERROR_INVALID_FIELD;
538 MSI_FreeField( &rec->fields[iField] );
539 if( szValue && szValue[0] )
541 str = strdupAtoW( szValue );
542 rec->fields[iField].type = MSIFIELD_WSTR;
543 rec->fields[iField].u.szwVal = str;
545 else
547 rec->fields[iField].type = MSIFIELD_NULL;
548 rec->fields[iField].u.szwVal = NULL;
551 return 0;
554 UINT WINAPI MsiRecordSetStringA( MSIHANDLE handle, UINT iField, LPCSTR szValue )
556 MSIRECORD *rec;
557 UINT ret;
559 TRACE("%ld %d %s\n", handle, iField, debugstr_a(szValue));
561 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
562 if( !rec )
563 return ERROR_INVALID_HANDLE;
564 msiobj_lock( &rec->hdr );
565 ret = MSI_RecordSetStringA( rec, iField, szValue );
566 msiobj_unlock( &rec->hdr );
567 msiobj_release( &rec->hdr );
568 return ret;
571 UINT MSI_RecordSetStringW( MSIRECORD *rec, UINT iField, LPCWSTR szValue )
573 LPWSTR str;
575 TRACE("%p %d %s\n", rec, iField, debugstr_w(szValue));
577 if( iField > rec->count )
578 return ERROR_INVALID_FIELD;
580 MSI_FreeField( &rec->fields[iField] );
582 if( szValue && szValue[0] )
584 str = strdupW( szValue );
585 rec->fields[iField].type = MSIFIELD_WSTR;
586 rec->fields[iField].u.szwVal = str;
588 else
590 rec->fields[iField].type = MSIFIELD_NULL;
591 rec->fields[iField].u.szwVal = NULL;
594 return 0;
597 UINT WINAPI MsiRecordSetStringW( MSIHANDLE handle, UINT iField, LPCWSTR szValue )
599 MSIRECORD *rec;
600 UINT ret;
602 TRACE("%ld %d %s\n", handle, iField, debugstr_w(szValue));
604 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
605 if( !rec )
606 return ERROR_INVALID_HANDLE;
608 msiobj_lock( &rec->hdr );
609 ret = MSI_RecordSetStringW( rec, iField, szValue );
610 msiobj_unlock( &rec->hdr );
611 msiobj_release( &rec->hdr );
612 return ret;
615 /* read the data in a file into an IStream */
616 static UINT RECORD_StreamFromFile(LPCWSTR szFile, IStream **pstm)
618 DWORD sz, szHighWord = 0, read;
619 HANDLE handle;
620 HGLOBAL hGlob = 0;
621 HRESULT hr;
622 ULARGE_INTEGER ulSize;
624 TRACE("reading %s\n", debugstr_w(szFile));
626 /* read the file into memory */
627 handle = CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
628 if( handle == INVALID_HANDLE_VALUE )
629 return GetLastError();
630 sz = GetFileSize(handle, &szHighWord);
631 if( sz != INVALID_FILE_SIZE && szHighWord == 0 )
633 hGlob = GlobalAlloc(GMEM_FIXED, sz);
634 if( hGlob )
636 BOOL r = ReadFile(handle, hGlob, sz, &read, NULL);
637 if( !r )
639 GlobalFree(hGlob);
640 hGlob = 0;
644 CloseHandle(handle);
645 if( !hGlob )
646 return ERROR_FUNCTION_FAILED;
648 /* make a stream out of it, and set the correct file size */
649 hr = CreateStreamOnHGlobal(hGlob, TRUE, pstm);
650 if( FAILED( hr ) )
652 GlobalFree(hGlob);
653 return ERROR_FUNCTION_FAILED;
656 /* set the correct size - CreateStreamOnHGlobal screws it up */
657 ulSize.QuadPart = sz;
658 IStream_SetSize(*pstm, ulSize);
660 TRACE("read %s, %d bytes into IStream %p\n", debugstr_w(szFile), sz, *pstm);
662 return ERROR_SUCCESS;
665 UINT MSI_RecordSetStream(MSIRECORD *rec, UINT iField, IStream *stream)
667 if ( (iField == 0) || (iField > rec->count) )
668 return ERROR_INVALID_PARAMETER;
670 MSI_FreeField( &rec->fields[iField] );
671 rec->fields[iField].type = MSIFIELD_STREAM;
672 rec->fields[iField].u.stream = stream;
674 return ERROR_SUCCESS;
677 static UINT MSI_RecordSetStreamFromFileW(MSIRECORD *rec, UINT iField, LPCWSTR szFilename)
679 IStream *stm = NULL;
680 HRESULT r;
682 if( (iField == 0) || (iField > rec->count) )
683 return ERROR_INVALID_PARAMETER;
685 /* no filename means we should seek back to the start of the stream */
686 if( !szFilename )
688 LARGE_INTEGER ofs;
689 ULARGE_INTEGER cur;
691 if( rec->fields[iField].type != MSIFIELD_STREAM )
692 return ERROR_INVALID_FIELD;
694 stm = rec->fields[iField].u.stream;
695 if( !stm )
696 return ERROR_INVALID_FIELD;
698 ofs.QuadPart = 0;
699 r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
700 if( FAILED( r ) )
701 return ERROR_FUNCTION_FAILED;
703 else
705 /* read the file into a stream and save the stream in the record */
706 r = RECORD_StreamFromFile(szFilename, &stm);
707 if( r != ERROR_SUCCESS )
708 return r;
710 /* if all's good, store it in the record */
711 MSI_RecordSetStream(rec, iField, stm);
714 return ERROR_SUCCESS;
717 UINT WINAPI MsiRecordSetStreamA(MSIHANDLE hRecord, UINT iField, LPCSTR szFilename)
719 LPWSTR wstr = NULL;
720 UINT ret;
722 TRACE("%ld %d %s\n", hRecord, iField, debugstr_a(szFilename));
724 if( szFilename )
726 wstr = strdupAtoW( szFilename );
727 if( !wstr )
728 return ERROR_OUTOFMEMORY;
730 ret = MsiRecordSetStreamW(hRecord, iField, wstr);
731 msi_free(wstr);
733 return ret;
736 UINT WINAPI MsiRecordSetStreamW(MSIHANDLE handle, UINT iField, LPCWSTR szFilename)
738 MSIRECORD *rec;
739 UINT ret;
741 TRACE("%ld %d %s\n", handle, iField, debugstr_w(szFilename));
743 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
744 if( !rec )
745 return ERROR_INVALID_HANDLE;
747 msiobj_lock( &rec->hdr );
748 ret = MSI_RecordSetStreamFromFileW( rec, iField, szFilename );
749 msiobj_unlock( &rec->hdr );
750 msiobj_release( &rec->hdr );
751 return ret;
754 UINT MSI_RecordReadStream(MSIRECORD *rec, UINT iField, char *buf, LPDWORD sz)
756 ULONG count;
757 HRESULT r;
758 IStream *stm;
760 TRACE("%p %d %p %p\n", rec, iField, buf, sz);
762 if( !sz )
763 return ERROR_INVALID_PARAMETER;
765 if( iField > rec->count)
766 return ERROR_INVALID_PARAMETER;
768 if( rec->fields[iField].type != MSIFIELD_STREAM )
769 return ERROR_INVALID_DATATYPE;
771 stm = rec->fields[iField].u.stream;
772 if( !stm )
773 return ERROR_INVALID_PARAMETER;
775 /* if there's no buffer pointer, calculate the length to the end */
776 if( !buf )
778 LARGE_INTEGER ofs;
779 ULARGE_INTEGER end, cur;
781 ofs.QuadPart = cur.QuadPart = 0;
782 end.QuadPart = 0;
783 r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
784 IStream_Seek( stm, ofs, STREAM_SEEK_END, &end );
785 ofs.QuadPart = cur.QuadPart;
786 IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
787 *sz = end.QuadPart - cur.QuadPart;
789 return ERROR_SUCCESS;
792 /* read the data */
793 count = 0;
794 r = IStream_Read( stm, buf, *sz, &count );
795 if( FAILED( r ) )
797 *sz = 0;
798 return ERROR_FUNCTION_FAILED;
801 *sz = count;
803 return ERROR_SUCCESS;
806 UINT WINAPI MsiRecordReadStream(MSIHANDLE handle, UINT iField, char *buf, LPDWORD sz)
808 MSIRECORD *rec;
809 UINT ret;
811 TRACE("%ld %d %p %p\n", handle, iField, buf, sz);
813 rec = msihandle2msiinfo( handle, MSIHANDLETYPE_RECORD );
814 if( !rec )
815 return ERROR_INVALID_HANDLE;
816 msiobj_lock( &rec->hdr );
817 ret = MSI_RecordReadStream( rec, iField, buf, sz );
818 msiobj_unlock( &rec->hdr );
819 msiobj_release( &rec->hdr );
820 return ret;
823 UINT MSI_RecordSetIStream( MSIRECORD *rec, UINT iField, IStream *stm )
825 TRACE("%p %d %p\n", rec, iField, stm);
827 if( iField > rec->count )
828 return ERROR_INVALID_FIELD;
830 MSI_FreeField( &rec->fields[iField] );
832 rec->fields[iField].type = MSIFIELD_STREAM;
833 rec->fields[iField].u.stream = stm;
834 IStream_AddRef( stm );
836 return ERROR_SUCCESS;
839 UINT MSI_RecordGetIStream( MSIRECORD *rec, UINT iField, IStream **pstm)
841 TRACE("%p %d %p\n", rec, iField, pstm);
843 if( iField > rec->count )
844 return ERROR_INVALID_FIELD;
846 if( rec->fields[iField].type != MSIFIELD_STREAM )
847 return ERROR_INVALID_FIELD;
849 *pstm = rec->fields[iField].u.stream;
850 IStream_AddRef( *pstm );
852 return ERROR_SUCCESS;
855 static UINT msi_dump_stream_to_file( IStream *stm, LPCWSTR name )
857 ULARGE_INTEGER size;
858 LARGE_INTEGER pos;
859 IStream *out;
860 DWORD stgm;
861 HRESULT r;
863 stgm = STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE;
864 r = SHCreateStreamOnFileW( name, stgm, &out );
865 if( FAILED( r ) )
866 return ERROR_FUNCTION_FAILED;
868 pos.QuadPart = 0;
869 r = IStream_Seek( stm, pos, STREAM_SEEK_END, &size );
870 if( FAILED( r ) )
871 goto end;
873 pos.QuadPart = 0;
874 r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
875 if( FAILED( r ) )
876 goto end;
878 r = IStream_CopyTo( stm, out, size, NULL, NULL );
880 end:
881 IStream_Release( out );
882 if( FAILED( r ) )
883 return ERROR_FUNCTION_FAILED;
884 return ERROR_SUCCESS;
887 UINT MSI_RecordStreamToFile( MSIRECORD *rec, UINT iField, LPCWSTR name )
889 IStream *stm = NULL;
890 UINT r;
892 TRACE("%p %u %s\n", rec, iField, debugstr_w(name));
894 msiobj_lock( &rec->hdr );
896 r = MSI_RecordGetIStream( rec, iField, &stm );
897 if( r == ERROR_SUCCESS )
899 r = msi_dump_stream_to_file( stm, name );
900 IStream_Release( stm );
903 msiobj_unlock( &rec->hdr );
905 return r;
908 MSIRECORD *MSI_CloneRecord(MSIRECORD *rec)
910 MSIRECORD *clone;
911 UINT r, i, count;
913 count = MSI_RecordGetFieldCount(rec);
914 clone = MSI_CreateRecord(count);
915 if (!clone)
916 return NULL;
918 for (i = 0; i <= count; i++)
920 if (rec->fields[i].type == MSIFIELD_STREAM)
922 if (FAILED(IStream_Clone(rec->fields[i].u.stream,
923 &clone->fields[i].u.stream)))
925 msiobj_release(&clone->hdr);
926 return NULL;
929 else
931 r = MSI_RecordCopyField(rec, i, clone, i);
932 if (r != ERROR_SUCCESS)
934 msiobj_release(&clone->hdr);
935 return NULL;
940 return clone;
943 BOOL MSI_RecordsAreEqual(MSIRECORD *a, MSIRECORD *b)
945 UINT i;
947 if (a->count != b->count)
948 return FALSE;
950 for (i = 0; i <= a->count; i++)
952 if (a->fields[i].type != b->fields[i].type)
953 return FALSE;
955 switch (a->fields[i].type)
957 case MSIFIELD_NULL:
958 break;
960 case MSIFIELD_INT:
961 if (a->fields[i].u.iVal != b->fields[i].u.iVal)
962 return FALSE;
963 break;
965 case MSIFIELD_WSTR:
966 if (lstrcmpW(a->fields[i].u.szwVal, b->fields[i].u.szwVal))
967 return FALSE;
968 break;
970 case MSIFIELD_STREAM:
971 default:
972 return FALSE;
976 return TRUE;