2 * Implementation of the Microsoft Installer (msi.dll)
4 * Copyright 2002,2003,2004,2005 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
25 #define NONAMELESSUNION
31 #include "wine/debug.h"
32 #include "wine/unicode.h"
38 #include "msiserver.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(msi
);
48 * An .msi file is a structured storage file.
49 * It contains a number of streams.
50 * A stream for each table in the database.
51 * Two streams for the string table in the database.
52 * Any binary data in a table is a reference to a stream.
55 #define IS_INTMSIDBOPEN(x) (((ULONG_PTR)(x) >> 16) == 0)
57 typedef struct tagMSITRANSFORM
{
62 typedef struct tagMSISTREAM
{
67 static UINT
find_open_stream( MSIDATABASE
*db
, LPCWSTR name
, IStream
**stm
)
71 LIST_FOR_EACH_ENTRY( stream
, &db
->streams
, MSISTREAM
, entry
)
76 r
= IStream_Stat( stream
->stm
, &stat
, 0 );
79 WARN("failed to stat stream r = %08x!\n", r
);
83 if( !strcmpW( name
, stat
.pwcsName
) )
85 TRACE("found %s\n", debugstr_w(name
));
87 CoTaskMemFree( stat
.pwcsName
);
91 CoTaskMemFree( stat
.pwcsName
);
94 return ERROR_FUNCTION_FAILED
;
97 static UINT
clone_open_stream( MSIDATABASE
*db
, LPCWSTR name
, IStream
**stm
)
101 if (find_open_stream( db
, name
, &stream
) == ERROR_SUCCESS
)
106 r
= IStream_Clone( stream
, stm
);
109 WARN("failed to clone stream r = %08x!\n", r
);
110 return ERROR_FUNCTION_FAILED
;
114 r
= IStream_Seek( *stm
, pos
, STREAM_SEEK_SET
, NULL
);
117 IStream_Release( *stm
);
118 return ERROR_FUNCTION_FAILED
;
121 return ERROR_SUCCESS
;
124 return ERROR_FUNCTION_FAILED
;
127 UINT
db_get_raw_stream( MSIDATABASE
*db
, LPCWSTR stname
, IStream
**stm
)
130 WCHAR decoded
[MAX_STREAM_NAME_LEN
];
132 decode_streamname( stname
, decoded
);
133 TRACE("%s -> %s\n", debugstr_w(stname
), debugstr_w(decoded
));
135 if (clone_open_stream( db
, stname
, stm
) == ERROR_SUCCESS
)
136 return ERROR_SUCCESS
;
138 r
= IStorage_OpenStream( db
->storage
, stname
, NULL
,
139 STGM_READ
| STGM_SHARE_EXCLUSIVE
, 0, stm
);
142 MSITRANSFORM
*transform
;
144 LIST_FOR_EACH_ENTRY( transform
, &db
->transforms
, MSITRANSFORM
, entry
)
146 r
= IStorage_OpenStream( transform
->stg
, stname
, NULL
,
147 STGM_READ
| STGM_SHARE_EXCLUSIVE
, 0, stm
);
157 stream
= msi_alloc( sizeof(MSISTREAM
) );
159 return ERROR_NOT_ENOUGH_MEMORY
;
162 IStream_AddRef( *stm
);
163 list_add_tail( &db
->streams
, &stream
->entry
);
166 return SUCCEEDED(r
) ? ERROR_SUCCESS
: ERROR_FUNCTION_FAILED
;
169 static void free_transforms( MSIDATABASE
*db
)
171 while( !list_empty( &db
->transforms
) )
173 MSITRANSFORM
*t
= LIST_ENTRY( list_head( &db
->transforms
),
174 MSITRANSFORM
, entry
);
175 list_remove( &t
->entry
);
176 IStorage_Release( t
->stg
);
181 void db_destroy_stream( MSIDATABASE
*db
, LPCWSTR stname
)
183 MSISTREAM
*stream
, *stream2
;
185 LIST_FOR_EACH_ENTRY_SAFE( stream
, stream2
, &db
->streams
, MSISTREAM
, entry
)
190 r
= IStream_Stat( stream
->stm
, &stat
, 0 );
193 WARN("failed to stat stream r = %08x\n", r
);
197 if (!strcmpW( stname
, stat
.pwcsName
))
199 TRACE("destroying %s\n", debugstr_w(stname
));
201 list_remove( &stream
->entry
);
202 IStream_Release( stream
->stm
);
204 IStorage_DestroyElement( db
->storage
, stname
);
205 CoTaskMemFree( stat
.pwcsName
);
208 CoTaskMemFree( stat
.pwcsName
);
212 static void free_streams( MSIDATABASE
*db
)
214 while( !list_empty( &db
->streams
) )
216 MSISTREAM
*s
= LIST_ENTRY( list_head( &db
->streams
),
218 list_remove( &s
->entry
);
219 IStream_Release( s
->stm
);
224 void append_storage_to_db( MSIDATABASE
*db
, IStorage
*stg
)
228 t
= msi_alloc( sizeof *t
);
230 IStorage_AddRef( stg
);
231 list_add_head( &db
->transforms
, &t
->entry
);
233 /* the transform may add or replace streams */
237 static VOID
MSI_CloseDatabase( MSIOBJECTHDR
*arg
)
239 MSIDATABASE
*db
= (MSIDATABASE
*) arg
;
242 free_cached_tables( db
);
244 free_transforms( db
);
245 if (db
->strings
) msi_destroy_stringtable( db
->strings
);
246 IStorage_Release( db
->storage
);
249 DeleteFileW( db
->deletefile
);
250 msi_free( db
->deletefile
);
254 DeleteFileW( db
->localfile
);
255 msi_free( db
->localfile
);
259 static HRESULT
db_initialize( IStorage
*stg
, const GUID
*clsid
)
261 static const WCHAR szTables
[] = { '_','T','a','b','l','e','s',0 };
264 hr
= IStorage_SetClass( stg
, clsid
);
267 WARN("failed to set class id 0x%08x\n", hr
);
271 /* create the _Tables stream */
272 hr
= write_stream_data( stg
, szTables
, NULL
, 0, TRUE
);
275 WARN("failed to create _Tables stream 0x%08x\n", hr
);
279 hr
= msi_init_string_table( stg
);
282 WARN("failed to initialize string table 0x%08x\n", hr
);
286 hr
= IStorage_Commit( stg
, 0 );
289 WARN("failed to commit changes 0x%08x\n", hr
);
296 UINT
MSI_OpenDatabaseW(LPCWSTR szDBPath
, LPCWSTR szPersist
, MSIDATABASE
**pdb
)
298 IStorage
*stg
= NULL
;
300 MSIDATABASE
*db
= NULL
;
301 UINT ret
= ERROR_FUNCTION_FAILED
;
302 LPCWSTR szMode
, save_path
;
304 BOOL created
= FALSE
, patch
= FALSE
;
305 WCHAR path
[MAX_PATH
];
307 TRACE("%s %s\n",debugstr_w(szDBPath
),debugstr_w(szPersist
) );
310 return ERROR_INVALID_PARAMETER
;
312 if (szPersist
- MSIDBOPEN_PATCHFILE
>= MSIDBOPEN_READONLY
&&
313 szPersist
- MSIDBOPEN_PATCHFILE
<= MSIDBOPEN_CREATEDIRECT
)
315 TRACE("Database is a patch\n");
316 szPersist
-= MSIDBOPEN_PATCHFILE
;
320 save_path
= szDBPath
;
322 if( !IS_INTMSIDBOPEN(szPersist
) )
324 if (!CopyFileW( szDBPath
, szPersist
, FALSE
))
325 return ERROR_OPEN_FAILED
;
327 szDBPath
= szPersist
;
328 szPersist
= MSIDBOPEN_TRANSACT
;
332 if( szPersist
== MSIDBOPEN_READONLY
)
334 r
= StgOpenStorage( szDBPath
, NULL
,
335 STGM_DIRECT
|STGM_READ
|STGM_SHARE_DENY_WRITE
, NULL
, 0, &stg
);
337 else if( szPersist
== MSIDBOPEN_CREATE
)
339 r
= StgCreateDocfile( szDBPath
,
340 STGM_CREATE
|STGM_TRANSACTED
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, 0, &stg
);
343 r
= db_initialize( stg
, patch
? &CLSID_MsiPatch
: &CLSID_MsiDatabase
);
346 else if( szPersist
== MSIDBOPEN_CREATEDIRECT
)
348 r
= StgCreateDocfile( szDBPath
,
349 STGM_CREATE
|STGM_DIRECT
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, 0, &stg
);
352 r
= db_initialize( stg
, patch
? &CLSID_MsiPatch
: &CLSID_MsiDatabase
);
355 else if( szPersist
== MSIDBOPEN_TRANSACT
)
357 r
= StgOpenStorage( szDBPath
, NULL
,
358 STGM_TRANSACTED
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg
);
360 else if( szPersist
== MSIDBOPEN_DIRECT
)
362 r
= StgOpenStorage( szDBPath
, NULL
,
363 STGM_DIRECT
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg
);
367 ERR("unknown flag %p\n",szPersist
);
368 return ERROR_INVALID_PARAMETER
;
371 if( FAILED( r
) || !stg
)
373 FIXME("open failed r = %08x for %s\n", r
, debugstr_w(szDBPath
));
374 return ERROR_FUNCTION_FAILED
;
377 r
= IStorage_Stat( stg
, &stat
, STATFLAG_NONAME
);
380 FIXME("Failed to stat storage\n");
384 if ( !IsEqualGUID( &stat
.clsid
, &CLSID_MsiDatabase
) &&
385 !IsEqualGUID( &stat
.clsid
, &CLSID_MsiPatch
) &&
386 !IsEqualGUID( &stat
.clsid
, &CLSID_MsiTransform
) )
388 ERR("storage GUID is not a MSI database GUID %s\n",
389 debugstr_guid(&stat
.clsid
) );
393 if ( patch
&& !IsEqualGUID( &stat
.clsid
, &CLSID_MsiPatch
) )
395 ERR("storage GUID is not the MSI patch GUID %s\n",
396 debugstr_guid(&stat
.clsid
) );
397 ret
= ERROR_OPEN_FAILED
;
401 db
= alloc_msiobject( MSIHANDLETYPE_DATABASE
, sizeof (MSIDATABASE
),
405 FIXME("Failed to allocate a handle\n");
409 if (!strchrW( save_path
, '\\' ))
411 GetCurrentDirectoryW( MAX_PATH
, path
);
412 lstrcatW( path
, szBackSlash
);
413 lstrcatW( path
, save_path
);
416 lstrcpyW( path
, save_path
);
418 db
->path
= strdupW( path
);
420 db
->media_transform_offset
= MSI_INITIAL_MEDIA_TRANSFORM_OFFSET
;
422 if( TRACE_ON( msi
) )
423 enum_stream_names( stg
);
428 db
->deletefile
= strdupW( szDBPath
);
429 list_init( &db
->tables
);
430 list_init( &db
->transforms
);
431 list_init( &db
->streams
);
433 db
->strings
= msi_load_string_table( stg
, &db
->bytes_per_strref
);
439 msiobj_addref( &db
->hdr
);
440 IStorage_AddRef( stg
);
445 msiobj_release( &db
->hdr
);
447 IStorage_Release( stg
);
452 UINT WINAPI
MsiOpenDatabaseW(LPCWSTR szDBPath
, LPCWSTR szPersist
, MSIHANDLE
*phDB
)
457 TRACE("%s %s %p\n",debugstr_w(szDBPath
),debugstr_w(szPersist
), phDB
);
459 ret
= MSI_OpenDatabaseW( szDBPath
, szPersist
, &db
);
460 if( ret
== ERROR_SUCCESS
)
462 *phDB
= alloc_msihandle( &db
->hdr
);
464 ret
= ERROR_NOT_ENOUGH_MEMORY
;
465 msiobj_release( &db
->hdr
);
471 UINT WINAPI
MsiOpenDatabaseA(LPCSTR szDBPath
, LPCSTR szPersist
, MSIHANDLE
*phDB
)
473 HRESULT r
= ERROR_FUNCTION_FAILED
;
474 LPWSTR szwDBPath
= NULL
, szwPersist
= NULL
;
476 TRACE("%s %s %p\n", debugstr_a(szDBPath
), debugstr_a(szPersist
), phDB
);
480 szwDBPath
= strdupAtoW( szDBPath
);
485 if( !IS_INTMSIDBOPEN(szPersist
) )
487 szwPersist
= strdupAtoW( szPersist
);
492 szwPersist
= (LPWSTR
)(DWORD_PTR
)szPersist
;
494 r
= MsiOpenDatabaseW( szwDBPath
, szwPersist
, phDB
);
497 if( !IS_INTMSIDBOPEN(szPersist
) )
498 msi_free( szwPersist
);
499 msi_free( szwDBPath
);
504 static LPWSTR
msi_read_text_archive(LPCWSTR path
)
509 DWORD read
, size
= 0;
511 file
= CreateFileW( path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, NULL
);
512 if (file
== INVALID_HANDLE_VALUE
)
515 size
= GetFileSize( file
, NULL
);
516 data
= msi_alloc( size
+ 1 );
520 if (!ReadFile( file
, data
, size
, &read
, NULL
))
524 wdata
= strdupAtoW( data
);
532 static void msi_parse_line(LPWSTR
*line
, LPWSTR
**entries
, DWORD
*num_entries
)
534 LPWSTR ptr
= *line
, save
;
539 /* stay on this line */
540 while (*ptr
&& *ptr
!= '\n')
542 /* entries are separated by tabs */
549 *entries
= msi_alloc(count
* sizeof(LPWSTR
));
553 /* store pointers into the data */
554 for (i
= 0, ptr
= *line
; i
< count
; i
++)
556 while (*ptr
&& *ptr
== '\r') ptr
++;
559 while (*ptr
&& *ptr
!= '\t' && *ptr
!= '\n' && *ptr
!= '\r') ptr
++;
561 /* NULL-separate the data */
562 if (*ptr
== '\n' || *ptr
== '\r')
564 while (*ptr
== '\n' || *ptr
== '\r')
570 (*entries
)[i
] = save
;
573 /* move to the next line if there's more, else EOF */
577 *num_entries
= count
;
580 static LPWSTR
msi_build_createsql_prelude(LPWSTR table
)
585 static const WCHAR create_fmt
[] = {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','%','s','`',' ','(',' ',0};
587 size
= sizeof(create_fmt
)/sizeof(create_fmt
[0]) + lstrlenW(table
) - 2;
588 prelude
= msi_alloc(size
* sizeof(WCHAR
));
592 sprintfW(prelude
, create_fmt
, table
);
596 static LPWSTR
msi_build_createsql_columns(LPWSTR
*columns_data
, LPWSTR
*types
, DWORD num_columns
)
600 DWORD sql_size
= 1, i
, len
;
601 WCHAR expanded
[128], *ptr
;
602 WCHAR size
[10], comma
[2], extra
[30];
604 static const WCHAR column_fmt
[] = {'`','%','s','`',' ','%','s','%','s','%','s','%','s',' ',0};
605 static const WCHAR size_fmt
[] = {'(','%','s',')',0};
606 static const WCHAR type_char
[] = {'C','H','A','R',0};
607 static const WCHAR type_int
[] = {'I','N','T',0};
608 static const WCHAR type_long
[] = {'L','O','N','G',0};
609 static const WCHAR type_object
[] = {'O','B','J','E','C','T',0};
610 static const WCHAR type_notnull
[] = {' ','N','O','T',' ','N','U','L','L',0};
611 static const WCHAR localizable
[] = {' ','L','O','C','A','L','I','Z','A','B','L','E',0};
613 columns
= msi_alloc_zero(sql_size
* sizeof(WCHAR
));
617 for (i
= 0; i
< num_columns
; i
++)
620 comma
[1] = size
[0] = extra
[0] = '\0';
622 if (i
== num_columns
- 1)
634 lstrcpyW(extra
, type_notnull
);
636 lstrcatW(extra
, localizable
);
638 sprintfW(size
, size_fmt
, ptr
);
641 lstrcpyW(extra
, type_notnull
);
644 sprintfW(size
, size_fmt
, ptr
);
647 lstrcpyW(extra
, type_notnull
);
655 WARN("invalid int width %u\n", len
);
661 lstrcpyW(extra
, type_notnull
);
666 ERR("Unknown type: %c\n", types
[i
][0]);
671 sprintfW(expanded
, column_fmt
, columns_data
[i
], type
, size
, extra
, comma
);
672 sql_size
+= lstrlenW(expanded
);
674 p
= msi_realloc(columns
, sql_size
* sizeof(WCHAR
));
682 lstrcatW(columns
, expanded
);
688 static LPWSTR
msi_build_createsql_postlude(LPWSTR
*primary_keys
, DWORD num_keys
)
690 LPWSTR postlude
, keys
, ptr
;
691 DWORD size
, key_size
, i
;
693 static const WCHAR key_fmt
[] = {'`','%','s','`',',',' ',0};
694 static const WCHAR postlude_fmt
[] = {'P','R','I','M','A','R','Y',' ','K','E','Y',' ','%','s',')',0};
696 for (i
= 0, size
= 1; i
< num_keys
; i
++)
697 size
+= lstrlenW(key_fmt
) + lstrlenW(primary_keys
[i
]) - 2;
699 keys
= msi_alloc(size
* sizeof(WCHAR
));
703 for (i
= 0, ptr
= keys
; i
< num_keys
; i
++)
705 key_size
= lstrlenW(key_fmt
) + lstrlenW(primary_keys
[i
]) -2;
706 sprintfW(ptr
, key_fmt
, primary_keys
[i
]);
710 /* remove final ', ' */
713 size
= lstrlenW(postlude_fmt
) + size
- 1;
714 postlude
= msi_alloc(size
* sizeof(WCHAR
));
718 sprintfW(postlude
, postlude_fmt
, keys
);
725 static UINT
msi_add_table_to_db(MSIDATABASE
*db
, LPWSTR
*columns
, LPWSTR
*types
, LPWSTR
*labels
, DWORD num_labels
, DWORD num_columns
)
727 UINT r
= ERROR_OUTOFMEMORY
;
730 LPWSTR create_sql
= NULL
;
731 LPWSTR prelude
, columns_sql
, postlude
;
733 prelude
= msi_build_createsql_prelude(labels
[0]);
734 columns_sql
= msi_build_createsql_columns(columns
, types
, num_columns
);
735 postlude
= msi_build_createsql_postlude(labels
+ 1, num_labels
- 1); /* skip over table name */
737 if (!prelude
|| !columns_sql
|| !postlude
)
740 size
= lstrlenW(prelude
) + lstrlenW(columns_sql
) + lstrlenW(postlude
) + 1;
741 create_sql
= msi_alloc(size
* sizeof(WCHAR
));
745 lstrcpyW(create_sql
, prelude
);
746 lstrcatW(create_sql
, columns_sql
);
747 lstrcatW(create_sql
, postlude
);
749 r
= MSI_DatabaseOpenViewW( db
, create_sql
, &view
);
750 if (r
!= ERROR_SUCCESS
)
753 r
= MSI_ViewExecute(view
, NULL
);
755 msiobj_release(&view
->hdr
);
759 msi_free(columns_sql
);
761 msi_free(create_sql
);
765 static LPWSTR
msi_import_stream_filename(LPCWSTR path
, LPCWSTR name
)
768 LPWSTR fullname
, ptr
;
770 len
= lstrlenW(path
) + lstrlenW(name
) + 1;
771 fullname
= msi_alloc(len
*sizeof(WCHAR
));
775 lstrcpyW( fullname
, path
);
777 /* chop off extension from path */
778 ptr
= strrchrW(fullname
, '.');
785 lstrcpyW( ptr
, name
);
789 static UINT
construct_record(DWORD num_columns
, LPWSTR
*types
,
790 LPWSTR
*data
, LPWSTR path
, MSIRECORD
**rec
)
794 *rec
= MSI_CreateRecord(num_columns
);
796 return ERROR_OUTOFMEMORY
;
798 for (i
= 0; i
< num_columns
; i
++)
802 case 'L': case 'l': case 'S': case 's':
803 MSI_RecordSetStringW(*rec
, i
+ 1, data
[i
]);
807 MSI_RecordSetInteger(*rec
, i
+ 1, atoiW(data
[i
]));
813 LPWSTR file
= msi_import_stream_filename(path
, data
[i
]);
815 return ERROR_FUNCTION_FAILED
;
817 r
= MSI_RecordSetStreamFromFileW(*rec
, i
+ 1, file
);
819 if (r
!= ERROR_SUCCESS
)
820 return ERROR_FUNCTION_FAILED
;
824 ERR("Unhandled column type: %c\n", types
[i
][0]);
825 msiobj_release(&(*rec
)->hdr
);
826 return ERROR_FUNCTION_FAILED
;
830 return ERROR_SUCCESS
;
833 static UINT
msi_add_records_to_table(MSIDATABASE
*db
, LPWSTR
*columns
, LPWSTR
*types
,
834 LPWSTR
*labels
, LPWSTR
**records
,
835 int num_columns
, int num_records
,
843 static const WCHAR select
[] = {
844 'S','E','L','E','C','T',' ','*',' ',
845 'F','R','O','M',' ','`','%','s','`',0
848 r
= MSI_OpenQuery(db
, &view
, select
, labels
[0]);
849 if (r
!= ERROR_SUCCESS
)
852 while (MSI_ViewFetch(view
, &rec
) != ERROR_NO_MORE_ITEMS
)
854 r
= MSI_ViewModify(view
, MSIMODIFY_DELETE
, rec
);
855 msiobj_release(&rec
->hdr
);
856 if (r
!= ERROR_SUCCESS
)
860 for (i
= 0; i
< num_records
; i
++)
862 r
= construct_record(num_columns
, types
, records
[i
], path
, &rec
);
863 if (r
!= ERROR_SUCCESS
)
866 r
= MSI_ViewModify(view
, MSIMODIFY_INSERT
, rec
);
867 if (r
!= ERROR_SUCCESS
)
869 msiobj_release(&rec
->hdr
);
873 msiobj_release(&rec
->hdr
);
877 msiobj_release(&view
->hdr
);
881 static UINT
MSI_DatabaseImport(MSIDATABASE
*db
, LPCWSTR folder
, LPCWSTR file
)
885 DWORD num_labels
, num_types
;
886 DWORD num_columns
, num_records
= 0;
887 LPWSTR
*columns
, *types
, *labels
;
888 LPWSTR path
, ptr
, data
;
889 LPWSTR
**records
= NULL
;
890 LPWSTR
**temp_records
;
892 static const WCHAR suminfo
[] =
893 {'_','S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',0};
894 static const WCHAR forcecodepage
[] =
895 {'_','F','o','r','c','e','C','o','d','e','p','a','g','e',0};
897 TRACE("%p %s %s\n", db
, debugstr_w(folder
), debugstr_w(file
) );
899 if( folder
== NULL
|| file
== NULL
)
900 return ERROR_INVALID_PARAMETER
;
902 len
= lstrlenW(folder
) + lstrlenW(szBackSlash
) + lstrlenW(file
) + 1;
903 path
= msi_alloc( len
* sizeof(WCHAR
) );
905 return ERROR_OUTOFMEMORY
;
907 lstrcpyW( path
, folder
);
908 lstrcatW( path
, szBackSlash
);
909 lstrcatW( path
, file
);
911 data
= msi_read_text_archive( path
);
914 msi_parse_line( &ptr
, &columns
, &num_columns
);
915 msi_parse_line( &ptr
, &types
, &num_types
);
916 msi_parse_line( &ptr
, &labels
, &num_labels
);
918 if (num_columns
== 1 && !columns
[0][0] && num_labels
== 1 && !labels
[0][0] &&
919 num_types
== 2 && !strcmpW( types
[1], forcecodepage
))
921 r
= msi_set_string_table_codepage( db
->strings
, atoiW( types
[0] ) );
925 if (num_columns
!= num_types
)
927 r
= ERROR_FUNCTION_FAILED
;
931 records
= msi_alloc(sizeof(LPWSTR
*));
934 r
= ERROR_OUTOFMEMORY
;
938 /* read in the table records */
941 msi_parse_line( &ptr
, &records
[num_records
], NULL
);
944 temp_records
= msi_realloc(records
, (num_records
+ 1) * sizeof(LPWSTR
*));
947 r
= ERROR_OUTOFMEMORY
;
950 records
= temp_records
;
953 if (!strcmpW(labels
[0], suminfo
))
955 r
= msi_add_suminfo( db
, records
, num_records
, num_columns
);
956 if (r
!= ERROR_SUCCESS
)
958 r
= ERROR_FUNCTION_FAILED
;
964 if (!TABLE_Exists(db
, labels
[0]))
966 r
= msi_add_table_to_db( db
, columns
, types
, labels
, num_labels
, num_columns
);
967 if (r
!= ERROR_SUCCESS
)
969 r
= ERROR_FUNCTION_FAILED
;
974 r
= msi_add_records_to_table( db
, columns
, types
, labels
, records
, num_columns
, num_records
, path
);
984 for (i
= 0; i
< num_records
; i
++)
985 msi_free(records
[i
]);
992 UINT WINAPI
MsiDatabaseImportW(MSIHANDLE handle
, LPCWSTR szFolder
, LPCWSTR szFilename
)
997 TRACE("%x %s %s\n",handle
,debugstr_w(szFolder
), debugstr_w(szFilename
));
999 db
= msihandle2msiinfo( handle
, MSIHANDLETYPE_DATABASE
);
1002 IWineMsiRemoteDatabase
*remote_database
;
1004 remote_database
= (IWineMsiRemoteDatabase
*)msi_get_remote( handle
);
1005 if ( !remote_database
)
1006 return ERROR_INVALID_HANDLE
;
1008 IWineMsiRemoteDatabase_Release( remote_database
);
1009 WARN("MsiDatabaseImport not allowed during a custom action!\n");
1011 return ERROR_SUCCESS
;
1014 r
= MSI_DatabaseImport( db
, szFolder
, szFilename
);
1015 msiobj_release( &db
->hdr
);
1019 UINT WINAPI
MsiDatabaseImportA( MSIHANDLE handle
,
1020 LPCSTR szFolder
, LPCSTR szFilename
)
1022 LPWSTR path
= NULL
, file
= NULL
;
1023 UINT r
= ERROR_OUTOFMEMORY
;
1025 TRACE("%x %s %s\n", handle
, debugstr_a(szFolder
), debugstr_a(szFilename
));
1029 path
= strdupAtoW( szFolder
);
1036 file
= strdupAtoW( szFilename
);
1041 r
= MsiDatabaseImportW( handle
, path
, file
);
1050 static UINT
msi_export_record( HANDLE handle
, MSIRECORD
*row
, UINT start
)
1052 UINT i
, count
, len
, r
= ERROR_SUCCESS
;
1058 buffer
= msi_alloc( len
);
1060 return ERROR_OUTOFMEMORY
;
1062 count
= MSI_RecordGetFieldCount( row
);
1063 for ( i
=start
; i
<=count
; i
++ )
1066 r
= MSI_RecordGetStringA( row
, i
, buffer
, &sz
);
1067 if (r
== ERROR_MORE_DATA
)
1069 char *p
= msi_realloc( buffer
, sz
+ 1 );
1076 r
= MSI_RecordGetStringA( row
, i
, buffer
, &sz
);
1077 if (r
!= ERROR_SUCCESS
)
1080 if (!WriteFile( handle
, buffer
, sz
, &sz
, NULL
))
1082 r
= ERROR_FUNCTION_FAILED
;
1086 sep
= (i
< count
) ? "\t" : "\r\n";
1087 if (!WriteFile( handle
, sep
, strlen(sep
), &sz
, NULL
))
1089 r
= ERROR_FUNCTION_FAILED
;
1097 static UINT
msi_export_row( MSIRECORD
*row
, void *arg
)
1099 return msi_export_record( arg
, row
, 1 );
1102 static UINT
msi_export_forcecodepage( HANDLE handle
, UINT codepage
)
1104 static const char fmt
[] = "\r\n\r\n%u\t_ForceCodepage\r\n";
1105 char data
[sizeof(fmt
) + 10];
1108 sprintf( data
, fmt
, codepage
);
1110 sz
= lstrlenA(data
) + 1;
1111 if (!WriteFile(handle
, data
, sz
, &sz
, NULL
))
1112 return ERROR_FUNCTION_FAILED
;
1114 return ERROR_SUCCESS
;
1117 static UINT
MSI_DatabaseExport( MSIDATABASE
*db
, LPCWSTR table
,
1118 LPCWSTR folder
, LPCWSTR file
)
1120 static const WCHAR query
[] = {
1121 's','e','l','e','c','t',' ','*',' ','f','r','o','m',' ','%','s',0 };
1122 static const WCHAR forcecodepage
[] = {
1123 '_','F','o','r','c','e','C','o','d','e','p','a','g','e',0 };
1124 MSIRECORD
*rec
= NULL
;
1125 MSIQUERY
*view
= NULL
;
1130 TRACE("%p %s %s %s\n", db
, debugstr_w(table
),
1131 debugstr_w(folder
), debugstr_w(file
) );
1133 if( folder
== NULL
|| file
== NULL
)
1134 return ERROR_INVALID_PARAMETER
;
1136 len
= lstrlenW(folder
) + lstrlenW(file
) + 2;
1137 filename
= msi_alloc(len
* sizeof (WCHAR
));
1139 return ERROR_OUTOFMEMORY
;
1141 lstrcpyW( filename
, folder
);
1142 lstrcatW( filename
, szBackSlash
);
1143 lstrcatW( filename
, file
);
1145 handle
= CreateFileW( filename
, GENERIC_READ
| GENERIC_WRITE
, 0,
1146 NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1147 msi_free( filename
);
1148 if (handle
== INVALID_HANDLE_VALUE
)
1149 return ERROR_FUNCTION_FAILED
;
1151 if (!strcmpW( table
, forcecodepage
))
1153 UINT codepage
= msi_get_string_table_codepage( db
->strings
);
1154 r
= msi_export_forcecodepage( handle
, codepage
);
1158 r
= MSI_OpenQuery( db
, &view
, query
, table
);
1159 if (r
== ERROR_SUCCESS
)
1161 /* write out row 1, the column names */
1162 r
= MSI_ViewGetColumnInfo(view
, MSICOLINFO_NAMES
, &rec
);
1163 if (r
== ERROR_SUCCESS
)
1165 msi_export_record( handle
, rec
, 1 );
1166 msiobj_release( &rec
->hdr
);
1169 /* write out row 2, the column types */
1170 r
= MSI_ViewGetColumnInfo(view
, MSICOLINFO_TYPES
, &rec
);
1171 if (r
== ERROR_SUCCESS
)
1173 msi_export_record( handle
, rec
, 1 );
1174 msiobj_release( &rec
->hdr
);
1177 /* write out row 3, the table name + keys */
1178 r
= MSI_DatabaseGetPrimaryKeys( db
, table
, &rec
);
1179 if (r
== ERROR_SUCCESS
)
1181 MSI_RecordSetStringW( rec
, 0, table
);
1182 msi_export_record( handle
, rec
, 0 );
1183 msiobj_release( &rec
->hdr
);
1186 /* write out row 4 onwards, the data */
1187 r
= MSI_IterateRecords( view
, 0, msi_export_row
, handle
);
1188 msiobj_release( &view
->hdr
);
1192 CloseHandle( handle
);
1196 /***********************************************************************
1197 * MsiExportDatabaseW [MSI.@]
1199 * Writes a file containing the table data as tab separated ASCII.
1201 * The format is as follows:
1203 * row1 : colname1 <tab> colname2 <tab> .... colnameN <cr> <lf>
1204 * row2 : coltype1 <tab> coltype2 <tab> .... coltypeN <cr> <lf>
1205 * row3 : tablename <tab> key1 <tab> key2 <tab> ... keyM <cr> <lf>
1207 * Followed by the data, starting at row 1 with one row per line
1209 * row4 : data <tab> data <tab> data <tab> ... data <cr> <lf>
1211 UINT WINAPI
MsiDatabaseExportW( MSIHANDLE handle
, LPCWSTR szTable
,
1212 LPCWSTR szFolder
, LPCWSTR szFilename
)
1217 TRACE("%x %s %s %s\n", handle
, debugstr_w(szTable
),
1218 debugstr_w(szFolder
), debugstr_w(szFilename
));
1220 db
= msihandle2msiinfo( handle
, MSIHANDLETYPE_DATABASE
);
1223 IWineMsiRemoteDatabase
*remote_database
;
1225 remote_database
= (IWineMsiRemoteDatabase
*)msi_get_remote( handle
);
1226 if ( !remote_database
)
1227 return ERROR_INVALID_HANDLE
;
1229 IWineMsiRemoteDatabase_Release( remote_database
);
1230 WARN("MsiDatabaseExport not allowed during a custom action!\n");
1232 return ERROR_SUCCESS
;
1235 r
= MSI_DatabaseExport( db
, szTable
, szFolder
, szFilename
);
1236 msiobj_release( &db
->hdr
);
1240 UINT WINAPI
MsiDatabaseExportA( MSIHANDLE handle
, LPCSTR szTable
,
1241 LPCSTR szFolder
, LPCSTR szFilename
)
1243 LPWSTR path
= NULL
, file
= NULL
, table
= NULL
;
1244 UINT r
= ERROR_OUTOFMEMORY
;
1246 TRACE("%x %s %s %s\n", handle
, debugstr_a(szTable
),
1247 debugstr_a(szFolder
), debugstr_a(szFilename
));
1251 table
= strdupAtoW( szTable
);
1258 path
= strdupAtoW( szFolder
);
1265 file
= strdupAtoW( szFilename
);
1270 r
= MsiDatabaseExportW( handle
, table
, path
, file
);
1280 UINT WINAPI
MsiDatabaseMergeA(MSIHANDLE hDatabase
, MSIHANDLE hDatabaseMerge
,
1286 TRACE("(%d, %d, %s)\n", hDatabase
, hDatabaseMerge
,
1287 debugstr_a(szTableName
));
1289 table
= strdupAtoW(szTableName
);
1290 r
= MsiDatabaseMergeW(hDatabase
, hDatabaseMerge
, table
);
1296 typedef struct _tagMERGETABLE
1310 typedef struct _tagMERGEROW
1316 typedef struct _tagMERGEDATA
1320 MERGETABLE
*curtable
;
1322 struct list
*tabledata
;
1325 static BOOL
merge_type_match(LPCWSTR type1
, LPCWSTR type2
)
1327 if (((type1
[0] == 'l') || (type1
[0] == 's')) &&
1328 ((type2
[0] == 'l') || (type2
[0] == 's')))
1331 if (((type1
[0] == 'L') || (type1
[0] == 'S')) &&
1332 ((type2
[0] == 'L') || (type2
[0] == 'S')))
1335 return !strcmpW( type1
, type2
);
1338 static UINT
merge_verify_colnames(MSIQUERY
*dbview
, MSIQUERY
*mergeview
)
1340 MSIRECORD
*dbrec
, *mergerec
;
1343 r
= MSI_ViewGetColumnInfo(dbview
, MSICOLINFO_NAMES
, &dbrec
);
1344 if (r
!= ERROR_SUCCESS
)
1347 r
= MSI_ViewGetColumnInfo(mergeview
, MSICOLINFO_NAMES
, &mergerec
);
1348 if (r
!= ERROR_SUCCESS
)
1351 count
= MSI_RecordGetFieldCount(dbrec
);
1352 for (i
= 1; i
<= count
; i
++)
1354 if (!MSI_RecordGetString(mergerec
, i
))
1357 if (strcmpW( MSI_RecordGetString( dbrec
, i
), MSI_RecordGetString( mergerec
, i
) ))
1359 r
= ERROR_DATATYPE_MISMATCH
;
1364 msiobj_release(&dbrec
->hdr
);
1365 msiobj_release(&mergerec
->hdr
);
1366 dbrec
= mergerec
= NULL
;
1368 r
= MSI_ViewGetColumnInfo(dbview
, MSICOLINFO_TYPES
, &dbrec
);
1369 if (r
!= ERROR_SUCCESS
)
1372 r
= MSI_ViewGetColumnInfo(mergeview
, MSICOLINFO_TYPES
, &mergerec
);
1373 if (r
!= ERROR_SUCCESS
)
1376 count
= MSI_RecordGetFieldCount(dbrec
);
1377 for (i
= 1; i
<= count
; i
++)
1379 if (!MSI_RecordGetString(mergerec
, i
))
1382 if (!merge_type_match(MSI_RecordGetString(dbrec
, i
),
1383 MSI_RecordGetString(mergerec
, i
)))
1385 r
= ERROR_DATATYPE_MISMATCH
;
1391 msiobj_release(&dbrec
->hdr
);
1392 msiobj_release(&mergerec
->hdr
);
1397 static UINT
merge_verify_primary_keys(MSIDATABASE
*db
, MSIDATABASE
*mergedb
,
1400 MSIRECORD
*dbrec
, *mergerec
= NULL
;
1403 r
= MSI_DatabaseGetPrimaryKeys(db
, table
, &dbrec
);
1404 if (r
!= ERROR_SUCCESS
)
1407 r
= MSI_DatabaseGetPrimaryKeys(mergedb
, table
, &mergerec
);
1408 if (r
!= ERROR_SUCCESS
)
1411 count
= MSI_RecordGetFieldCount(dbrec
);
1412 if (count
!= MSI_RecordGetFieldCount(mergerec
))
1414 r
= ERROR_DATATYPE_MISMATCH
;
1418 for (i
= 1; i
<= count
; i
++)
1420 if (strcmpW( MSI_RecordGetString( dbrec
, i
), MSI_RecordGetString( mergerec
, i
) ))
1422 r
= ERROR_DATATYPE_MISMATCH
;
1428 msiobj_release(&dbrec
->hdr
);
1429 msiobj_release(&mergerec
->hdr
);
1434 static LPWSTR
get_key_value(MSIQUERY
*view
, LPCWSTR key
, MSIRECORD
*rec
)
1436 MSIRECORD
*colnames
;
1438 UINT r
, i
= 0, sz
= 0;
1441 r
= MSI_ViewGetColumnInfo(view
, MSICOLINFO_NAMES
, &colnames
);
1442 if (r
!= ERROR_SUCCESS
)
1447 str
= msi_dup_record_field(colnames
, ++i
);
1448 cmp
= strcmpW( key
, str
);
1452 msiobj_release(&colnames
->hdr
);
1454 r
= MSI_RecordGetStringW(rec
, i
, NULL
, &sz
);
1455 if (r
!= ERROR_SUCCESS
)
1459 if (MSI_RecordGetString(rec
, i
)) /* check record field is a string */
1461 /* quote string record fields */
1462 const WCHAR szQuote
[] = {'\'', 0};
1464 val
= msi_alloc(sz
*sizeof(WCHAR
));
1468 lstrcpyW(val
, szQuote
);
1469 r
= MSI_RecordGetStringW(rec
, i
, val
+1, &sz
);
1470 lstrcpyW(val
+1+sz
, szQuote
);
1474 /* do not quote integer record fields */
1475 val
= msi_alloc(sz
*sizeof(WCHAR
));
1479 r
= MSI_RecordGetStringW(rec
, i
, val
, &sz
);
1482 if (r
!= ERROR_SUCCESS
)
1484 ERR("failed to get string!\n");
1492 static LPWSTR
create_diff_row_query(MSIDATABASE
*merge
, MSIQUERY
*view
,
1493 LPWSTR table
, MSIRECORD
*rec
)
1495 LPWSTR query
= NULL
, clause
= NULL
;
1496 LPWSTR ptr
= NULL
, val
;
1498 DWORD size
= 1, oldsize
;
1503 static const WCHAR keyset
[] = {
1504 '`','%','s','`',' ','=',' ','%','s',' ','A','N','D',' ',0};
1505 static const WCHAR lastkeyset
[] = {
1506 '`','%','s','`',' ','=',' ','%','s',' ',0};
1507 static const WCHAR fmt
[] = {'S','E','L','E','C','T',' ','*',' ',
1508 'F','R','O','M',' ','`','%','s','`',' ',
1509 'W','H','E','R','E',' ','%','s',0};
1511 r
= MSI_DatabaseGetPrimaryKeys(merge
, table
, &keys
);
1512 if (r
!= ERROR_SUCCESS
)
1515 clause
= msi_alloc_zero(size
* sizeof(WCHAR
));
1520 count
= MSI_RecordGetFieldCount(keys
);
1521 for (i
= 1; i
<= count
; i
++)
1523 key
= MSI_RecordGetString(keys
, i
);
1524 val
= get_key_value(view
, key
, rec
);
1527 setptr
= lastkeyset
;
1532 size
+= lstrlenW(setptr
) + lstrlenW(key
) + lstrlenW(val
) - 4;
1533 clause
= msi_realloc(clause
, size
* sizeof (WCHAR
));
1540 ptr
= clause
+ oldsize
- 1;
1541 sprintfW(ptr
, setptr
, key
, val
);
1545 size
= lstrlenW(fmt
) + lstrlenW(table
) + lstrlenW(clause
) + 1;
1546 query
= msi_alloc(size
* sizeof(WCHAR
));
1550 sprintfW(query
, fmt
, table
, clause
);
1554 msiobj_release(&keys
->hdr
);
1558 static UINT
merge_diff_row(MSIRECORD
*rec
, LPVOID param
)
1560 MERGEDATA
*data
= param
;
1561 MERGETABLE
*table
= data
->curtable
;
1563 MSIQUERY
*dbview
= NULL
;
1564 MSIRECORD
*row
= NULL
;
1565 LPWSTR query
= NULL
;
1566 UINT r
= ERROR_SUCCESS
;
1568 if (TABLE_Exists(data
->db
, table
->name
))
1570 query
= create_diff_row_query(data
->merge
, data
->curview
, table
->name
, rec
);
1572 return ERROR_OUTOFMEMORY
;
1574 r
= MSI_DatabaseOpenViewW(data
->db
, query
, &dbview
);
1575 if (r
!= ERROR_SUCCESS
)
1578 r
= MSI_ViewExecute(dbview
, NULL
);
1579 if (r
!= ERROR_SUCCESS
)
1582 r
= MSI_ViewFetch(dbview
, &row
);
1583 if (r
== ERROR_SUCCESS
&& !MSI_RecordsAreEqual(rec
, row
))
1585 table
->numconflicts
++;
1588 else if (r
!= ERROR_NO_MORE_ITEMS
)
1594 mergerow
= msi_alloc(sizeof(MERGEROW
));
1597 r
= ERROR_OUTOFMEMORY
;
1601 mergerow
->data
= MSI_CloneRecord(rec
);
1602 if (!mergerow
->data
)
1604 r
= ERROR_OUTOFMEMORY
;
1609 list_add_tail(&table
->rows
, &mergerow
->entry
);
1613 msiobj_release(&row
->hdr
);
1614 msiobj_release(&dbview
->hdr
);
1618 static UINT
msi_get_table_labels(MSIDATABASE
*db
, LPCWSTR table
, LPWSTR
**labels
, DWORD
*numlabels
)
1621 MSIRECORD
*prec
= NULL
;
1623 r
= MSI_DatabaseGetPrimaryKeys(db
, table
, &prec
);
1624 if (r
!= ERROR_SUCCESS
)
1627 count
= MSI_RecordGetFieldCount(prec
);
1628 *numlabels
= count
+ 1;
1629 *labels
= msi_alloc((*numlabels
)*sizeof(LPWSTR
));
1632 r
= ERROR_OUTOFMEMORY
;
1636 (*labels
)[0] = strdupW(table
);
1637 for (i
=1; i
<=count
; i
++ )
1639 (*labels
)[i
] = strdupW(MSI_RecordGetString(prec
, i
));
1643 msiobj_release( &prec
->hdr
);
1647 static UINT
msi_get_query_columns(MSIQUERY
*query
, LPWSTR
**columns
, DWORD
*numcolumns
)
1650 MSIRECORD
*prec
= NULL
;
1652 r
= MSI_ViewGetColumnInfo(query
, MSICOLINFO_NAMES
, &prec
);
1653 if (r
!= ERROR_SUCCESS
)
1656 count
= MSI_RecordGetFieldCount(prec
);
1657 *columns
= msi_alloc(count
*sizeof(LPWSTR
));
1660 r
= ERROR_OUTOFMEMORY
;
1664 for (i
=1; i
<=count
; i
++ )
1666 (*columns
)[i
-1] = strdupW(MSI_RecordGetString(prec
, i
));
1669 *numcolumns
= count
;
1672 msiobj_release( &prec
->hdr
);
1676 static UINT
msi_get_query_types(MSIQUERY
*query
, LPWSTR
**types
, DWORD
*numtypes
)
1679 MSIRECORD
*prec
= NULL
;
1681 r
= MSI_ViewGetColumnInfo(query
, MSICOLINFO_TYPES
, &prec
);
1682 if (r
!= ERROR_SUCCESS
)
1685 count
= MSI_RecordGetFieldCount(prec
);
1686 *types
= msi_alloc(count
*sizeof(LPWSTR
));
1689 r
= ERROR_OUTOFMEMORY
;
1694 for (i
=1; i
<=count
; i
++ )
1696 (*types
)[i
-1] = strdupW(MSI_RecordGetString(prec
, i
));
1700 msiobj_release( &prec
->hdr
);
1704 static void merge_free_rows(MERGETABLE
*table
)
1706 struct list
*item
, *cursor
;
1708 LIST_FOR_EACH_SAFE(item
, cursor
, &table
->rows
)
1710 MERGEROW
*row
= LIST_ENTRY(item
, MERGEROW
, entry
);
1712 list_remove(&row
->entry
);
1713 msiobj_release(&row
->data
->hdr
);
1718 static void free_merge_table(MERGETABLE
*table
)
1722 if (table
->labels
!= NULL
)
1724 for (i
= 0; i
< table
->numlabels
; i
++)
1725 msi_free(table
->labels
[i
]);
1727 msi_free(table
->labels
);
1730 if (table
->columns
!= NULL
)
1732 for (i
= 0; i
< table
->numcolumns
; i
++)
1733 msi_free(table
->columns
[i
]);
1735 msi_free(table
->columns
);
1738 if (table
->types
!= NULL
)
1740 for (i
= 0; i
< table
->numtypes
; i
++)
1741 msi_free(table
->types
[i
]);
1743 msi_free(table
->types
);
1746 msi_free(table
->name
);
1747 merge_free_rows(table
);
1752 static UINT
msi_get_merge_table (MSIDATABASE
*db
, LPCWSTR name
, MERGETABLE
**ptable
)
1756 MSIQUERY
*mergeview
= NULL
;
1758 static const WCHAR query
[] = {'S','E','L','E','C','T',' ','*',' ',
1759 'F','R','O','M',' ','`','%','s','`',0};
1761 table
= msi_alloc_zero(sizeof(MERGETABLE
));
1765 return ERROR_OUTOFMEMORY
;
1768 r
= msi_get_table_labels(db
, name
, &table
->labels
, &table
->numlabels
);
1769 if (r
!= ERROR_SUCCESS
)
1772 r
= MSI_OpenQuery(db
, &mergeview
, query
, name
);
1773 if (r
!= ERROR_SUCCESS
)
1776 r
= msi_get_query_columns(mergeview
, &table
->columns
, &table
->numcolumns
);
1777 if (r
!= ERROR_SUCCESS
)
1780 r
= msi_get_query_types(mergeview
, &table
->types
, &table
->numtypes
);
1781 if (r
!= ERROR_SUCCESS
)
1784 list_init(&table
->rows
);
1786 table
->name
= strdupW(name
);
1787 table
->numconflicts
= 0;
1789 msiobj_release(&mergeview
->hdr
);
1791 return ERROR_SUCCESS
;
1794 msiobj_release(&mergeview
->hdr
);
1795 free_merge_table(table
);
1800 static UINT
merge_diff_tables(MSIRECORD
*rec
, LPVOID param
)
1802 MERGEDATA
*data
= param
;
1804 MSIQUERY
*dbview
= NULL
;
1805 MSIQUERY
*mergeview
= NULL
;
1809 static const WCHAR query
[] = {'S','E','L','E','C','T',' ','*',' ',
1810 'F','R','O','M',' ','`','%','s','`',0};
1812 name
= MSI_RecordGetString(rec
, 1);
1814 r
= MSI_OpenQuery(data
->merge
, &mergeview
, query
, name
);
1815 if (r
!= ERROR_SUCCESS
)
1818 if (TABLE_Exists(data
->db
, name
))
1820 r
= MSI_OpenQuery(data
->db
, &dbview
, query
, name
);
1821 if (r
!= ERROR_SUCCESS
)
1824 r
= merge_verify_colnames(dbview
, mergeview
);
1825 if (r
!= ERROR_SUCCESS
)
1828 r
= merge_verify_primary_keys(data
->db
, data
->merge
, name
);
1829 if (r
!= ERROR_SUCCESS
)
1833 r
= msi_get_merge_table(data
->merge
, name
, &table
);
1834 if (r
!= ERROR_SUCCESS
)
1837 data
->curtable
= table
;
1838 data
->curview
= mergeview
;
1839 r
= MSI_IterateRecords(mergeview
, NULL
, merge_diff_row
, data
);
1840 if (r
!= ERROR_SUCCESS
)
1842 free_merge_table(table
);
1846 list_add_tail(data
->tabledata
, &table
->entry
);
1849 msiobj_release(&dbview
->hdr
);
1850 msiobj_release(&mergeview
->hdr
);
1854 static UINT
gather_merge_data(MSIDATABASE
*db
, MSIDATABASE
*merge
,
1855 struct list
*tabledata
)
1861 static const WCHAR query
[] = {'S','E','L','E','C','T',' ','*',' ',
1862 'F','R','O','M',' ','`','_','T','a','b','l','e','s','`',0};
1864 r
= MSI_DatabaseOpenViewW(merge
, query
, &view
);
1865 if (r
!= ERROR_SUCCESS
)
1870 data
.tabledata
= tabledata
;
1871 r
= MSI_IterateRecords(view
, NULL
, merge_diff_tables
, &data
);
1873 msiobj_release(&view
->hdr
);
1877 static UINT
merge_table(MSIDATABASE
*db
, MERGETABLE
*table
)
1883 if (!TABLE_Exists(db
, table
->name
))
1885 r
= msi_add_table_to_db(db
, table
->columns
, table
->types
,
1886 table
->labels
, table
->numlabels
, table
->numcolumns
);
1887 if (r
!= ERROR_SUCCESS
)
1888 return ERROR_FUNCTION_FAILED
;
1891 LIST_FOR_EACH_ENTRY(row
, &table
->rows
, MERGEROW
, entry
)
1893 r
= TABLE_CreateView(db
, table
->name
, &tv
);
1894 if (r
!= ERROR_SUCCESS
)
1897 r
= tv
->ops
->insert_row(tv
, row
->data
, -1, FALSE
);
1898 tv
->ops
->delete(tv
);
1900 if (r
!= ERROR_SUCCESS
)
1904 return ERROR_SUCCESS
;
1907 static UINT
update_merge_errors(MSIDATABASE
*db
, LPCWSTR error
,
1908 LPWSTR table
, DWORD numconflicts
)
1913 static const WCHAR create
[] = {
1914 'C','R','E','A','T','E',' ','T','A','B','L','E',' ',
1915 '`','%','s','`',' ','(','`','T','a','b','l','e','`',' ',
1916 'C','H','A','R','(','2','5','5',')',' ','N','O','T',' ',
1917 'N','U','L','L',',',' ','`','N','u','m','R','o','w','M','e','r','g','e',
1918 'C','o','n','f','l','i','c','t','s','`',' ','S','H','O','R','T',' ',
1919 'N','O','T',' ','N','U','L','L',' ','P','R','I','M','A','R','Y',' ',
1920 'K','E','Y',' ','`','T','a','b','l','e','`',')',0};
1921 static const WCHAR insert
[] = {
1922 'I','N','S','E','R','T',' ','I','N','T','O',' ',
1923 '`','%','s','`',' ','(','`','T','a','b','l','e','`',',',' ',
1924 '`','N','u','m','R','o','w','M','e','r','g','e',
1925 'C','o','n','f','l','i','c','t','s','`',')',' ','V','A','L','U','E','S',
1926 ' ','(','\'','%','s','\'',',',' ','%','d',')',0};
1928 if (!TABLE_Exists(db
, error
))
1930 r
= MSI_OpenQuery(db
, &view
, create
, error
);
1931 if (r
!= ERROR_SUCCESS
)
1934 r
= MSI_ViewExecute(view
, NULL
);
1935 msiobj_release(&view
->hdr
);
1936 if (r
!= ERROR_SUCCESS
)
1940 r
= MSI_OpenQuery(db
, &view
, insert
, error
, table
, numconflicts
);
1941 if (r
!= ERROR_SUCCESS
)
1944 r
= MSI_ViewExecute(view
, NULL
);
1945 msiobj_release(&view
->hdr
);
1949 UINT WINAPI
MsiDatabaseMergeW(MSIHANDLE hDatabase
, MSIHANDLE hDatabaseMerge
,
1950 LPCWSTR szTableName
)
1952 struct list tabledata
= LIST_INIT(tabledata
);
1953 struct list
*item
, *cursor
;
1954 MSIDATABASE
*db
, *merge
;
1959 TRACE("(%d, %d, %s)\n", hDatabase
, hDatabaseMerge
,
1960 debugstr_w(szTableName
));
1962 if (szTableName
&& !*szTableName
)
1963 return ERROR_INVALID_TABLE
;
1965 db
= msihandle2msiinfo(hDatabase
, MSIHANDLETYPE_DATABASE
);
1966 merge
= msihandle2msiinfo(hDatabaseMerge
, MSIHANDLETYPE_DATABASE
);
1969 r
= ERROR_INVALID_HANDLE
;
1973 r
= gather_merge_data(db
, merge
, &tabledata
);
1974 if (r
!= ERROR_SUCCESS
)
1978 LIST_FOR_EACH_ENTRY(table
, &tabledata
, MERGETABLE
, entry
)
1980 if (table
->numconflicts
)
1984 r
= update_merge_errors(db
, szTableName
, table
->name
,
1985 table
->numconflicts
);
1986 if (r
!= ERROR_SUCCESS
)
1991 r
= merge_table(db
, table
);
1992 if (r
!= ERROR_SUCCESS
)
1997 LIST_FOR_EACH_SAFE(item
, cursor
, &tabledata
)
1999 MERGETABLE
*table
= LIST_ENTRY(item
, MERGETABLE
, entry
);
2000 list_remove(&table
->entry
);
2001 free_merge_table(table
);
2005 r
= ERROR_FUNCTION_FAILED
;
2008 msiobj_release(&db
->hdr
);
2009 msiobj_release(&merge
->hdr
);
2013 MSIDBSTATE WINAPI
MsiGetDatabaseState( MSIHANDLE handle
)
2015 MSIDBSTATE ret
= MSIDBSTATE_READ
;
2018 TRACE("%d\n", handle
);
2020 db
= msihandle2msiinfo( handle
, MSIHANDLETYPE_DATABASE
);
2023 IWineMsiRemoteDatabase
*remote_database
;
2025 remote_database
= (IWineMsiRemoteDatabase
*)msi_get_remote( handle
);
2026 if ( !remote_database
)
2027 return MSIDBSTATE_ERROR
;
2029 IWineMsiRemoteDatabase_Release( remote_database
);
2030 WARN("MsiGetDatabaseState not allowed during a custom action!\n");
2032 return MSIDBSTATE_READ
;
2035 if (db
->mode
!= MSIDBOPEN_READONLY
)
2036 ret
= MSIDBSTATE_WRITE
;
2037 msiobj_release( &db
->hdr
);
2042 typedef struct _msi_remote_database_impl
{
2043 IWineMsiRemoteDatabase IWineMsiRemoteDatabase_iface
;
2046 } msi_remote_database_impl
;
2048 static inline msi_remote_database_impl
*impl_from_IWineMsiRemoteDatabase( IWineMsiRemoteDatabase
*iface
)
2050 return CONTAINING_RECORD(iface
, msi_remote_database_impl
, IWineMsiRemoteDatabase_iface
);
2053 static HRESULT WINAPI
mrd_QueryInterface( IWineMsiRemoteDatabase
*iface
,
2054 REFIID riid
,LPVOID
*ppobj
)
2056 if( IsEqualCLSID( riid
, &IID_IUnknown
) ||
2057 IsEqualCLSID( riid
, &IID_IWineMsiRemoteDatabase
) )
2059 IUnknown_AddRef( iface
);
2064 return E_NOINTERFACE
;
2067 static ULONG WINAPI
mrd_AddRef( IWineMsiRemoteDatabase
*iface
)
2069 msi_remote_database_impl
* This
= impl_from_IWineMsiRemoteDatabase( iface
);
2071 return InterlockedIncrement( &This
->refs
);
2074 static ULONG WINAPI
mrd_Release( IWineMsiRemoteDatabase
*iface
)
2076 msi_remote_database_impl
* This
= impl_from_IWineMsiRemoteDatabase( iface
);
2079 r
= InterlockedDecrement( &This
->refs
);
2082 MsiCloseHandle( This
->database
);
2088 static HRESULT WINAPI
mrd_IsTablePersistent( IWineMsiRemoteDatabase
*iface
,
2089 LPCWSTR table
, MSICONDITION
*persistent
)
2091 msi_remote_database_impl
*This
= impl_from_IWineMsiRemoteDatabase( iface
);
2092 *persistent
= MsiDatabaseIsTablePersistentW(This
->database
, table
);
2096 static HRESULT WINAPI
mrd_GetPrimaryKeys( IWineMsiRemoteDatabase
*iface
,
2097 LPCWSTR table
, MSIHANDLE
*keys
)
2099 msi_remote_database_impl
*This
= impl_from_IWineMsiRemoteDatabase( iface
);
2100 UINT r
= MsiDatabaseGetPrimaryKeysW(This
->database
, table
, keys
);
2101 return HRESULT_FROM_WIN32(r
);
2104 static HRESULT WINAPI
mrd_GetSummaryInformation( IWineMsiRemoteDatabase
*iface
,
2105 UINT updatecount
, MSIHANDLE
*suminfo
)
2107 msi_remote_database_impl
*This
= impl_from_IWineMsiRemoteDatabase( iface
);
2108 UINT r
= MsiGetSummaryInformationW(This
->database
, NULL
, updatecount
, suminfo
);
2109 return HRESULT_FROM_WIN32(r
);
2112 static HRESULT WINAPI
mrd_OpenView( IWineMsiRemoteDatabase
*iface
,
2113 LPCWSTR query
, MSIHANDLE
*view
)
2115 msi_remote_database_impl
*This
= impl_from_IWineMsiRemoteDatabase( iface
);
2116 UINT r
= MsiDatabaseOpenViewW(This
->database
, query
, view
);
2117 return HRESULT_FROM_WIN32(r
);
2120 static HRESULT WINAPI
mrd_SetMsiHandle( IWineMsiRemoteDatabase
*iface
, MSIHANDLE handle
)
2122 msi_remote_database_impl
* This
= impl_from_IWineMsiRemoteDatabase( iface
);
2123 This
->database
= handle
;
2127 static const IWineMsiRemoteDatabaseVtbl msi_remote_database_vtbl
=
2132 mrd_IsTablePersistent
,
2134 mrd_GetSummaryInformation
,
2139 HRESULT
create_msi_remote_database( IUnknown
*pOuter
, LPVOID
*ppObj
)
2141 msi_remote_database_impl
*This
;
2143 This
= msi_alloc( sizeof *This
);
2145 return E_OUTOFMEMORY
;
2147 This
->IWineMsiRemoteDatabase_iface
.lpVtbl
= &msi_remote_database_vtbl
;