01c32497a37b03cf381fa3a6c1c8061c7befb49d
[reactos.git] / reactos / dll / win32 / msi / database.c
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2002,2003,2004,2005 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 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winreg.h"
29 #include "winnls.h"
30 #include "wine/debug.h"
31 #include "wine/unicode.h"
32 #include "msi.h"
33 #include "msiquery.h"
34 #include "msipriv.h"
35 #include "objidl.h"
36 #include "objbase.h"
37 #include "msiserver.h"
38 #include "query.h"
39
40 #include "initguid.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(msi);
43
44 /*
45 * .MSI file format
46 *
47 * An .msi file is a structured storage file.
48 * It contains a number of streams.
49 * A stream for each table in the database.
50 * Two streams for the string table in the database.
51 * Any binary data in a table is a reference to a stream.
52 */
53
54 #define IS_INTMSIDBOPEN(x) (((ULONG_PTR)(x) >> 16) == 0)
55
56 typedef struct tagMSITRANSFORM {
57 struct list entry;
58 IStorage *stg;
59 } MSITRANSFORM;
60
61 typedef struct tagMSISTREAM {
62 struct list entry;
63 IStream *stm;
64 } MSISTREAM;
65
66 static UINT find_open_stream( MSIDATABASE *db, LPCWSTR name, IStream **stm )
67 {
68 MSISTREAM *stream;
69
70 LIST_FOR_EACH_ENTRY( stream, &db->streams, MSISTREAM, entry )
71 {
72 HRESULT r;
73 STATSTG stat;
74
75 r = IStream_Stat( stream->stm, &stat, 0 );
76 if( FAILED( r ) )
77 {
78 WARN("failed to stat stream r = %08x!\n", r);
79 continue;
80 }
81
82 if( !lstrcmpW( name, stat.pwcsName ) )
83 {
84 TRACE("found %s\n", debugstr_w(name));
85 *stm = stream->stm;
86 CoTaskMemFree( stat.pwcsName );
87 return ERROR_SUCCESS;
88 }
89
90 CoTaskMemFree( stat.pwcsName );
91 }
92
93 return ERROR_FUNCTION_FAILED;
94 }
95
96 static UINT clone_open_stream( MSIDATABASE *db, LPCWSTR name, IStream **stm )
97 {
98 IStream *stream;
99
100 if (find_open_stream( db, name, &stream ) == ERROR_SUCCESS)
101 {
102 HRESULT r;
103 LARGE_INTEGER pos;
104
105 r = IStream_Clone( stream, stm );
106 if( FAILED( r ) )
107 {
108 WARN("failed to clone stream r = %08x!\n", r);
109 return ERROR_FUNCTION_FAILED;
110 }
111
112 pos.QuadPart = 0;
113 r = IStream_Seek( *stm, pos, STREAM_SEEK_SET, NULL );
114 if( FAILED( r ) )
115 {
116 IStream_Release( *stm );
117 return ERROR_FUNCTION_FAILED;
118 }
119
120 return ERROR_SUCCESS;
121 }
122
123 return ERROR_FUNCTION_FAILED;
124 }
125
126 UINT db_get_raw_stream( MSIDATABASE *db, LPCWSTR stname, IStream **stm )
127 {
128 HRESULT r;
129 WCHAR decoded[MAX_STREAM_NAME_LEN];
130
131 decode_streamname( stname, decoded );
132 TRACE("%s -> %s\n", debugstr_w(stname), debugstr_w(decoded));
133
134 if (clone_open_stream( db, stname, stm ) == ERROR_SUCCESS)
135 return ERROR_SUCCESS;
136
137 r = IStorage_OpenStream( db->storage, stname, NULL,
138 STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm );
139 if( FAILED( r ) )
140 {
141 MSITRANSFORM *transform;
142
143 LIST_FOR_EACH_ENTRY( transform, &db->transforms, MSITRANSFORM, entry )
144 {
145 r = IStorage_OpenStream( transform->stg, stname, NULL,
146 STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm );
147 if (SUCCEEDED(r))
148 break;
149 }
150 }
151
152 if( SUCCEEDED(r) )
153 {
154 MSISTREAM *stream;
155
156 stream = msi_alloc( sizeof(MSISTREAM) );
157 if( !stream )
158 return ERROR_NOT_ENOUGH_MEMORY;
159
160 stream->stm = *stm;
161 IStream_AddRef( *stm );
162 list_add_tail( &db->streams, &stream->entry );
163 }
164
165 return SUCCEEDED(r) ? ERROR_SUCCESS : ERROR_FUNCTION_FAILED;
166 }
167
168 static void free_transforms( MSIDATABASE *db )
169 {
170 while( !list_empty( &db->transforms ) )
171 {
172 MSITRANSFORM *t = LIST_ENTRY( list_head( &db->transforms ),
173 MSITRANSFORM, entry );
174 list_remove( &t->entry );
175 IStorage_Release( t->stg );
176 msi_free( t );
177 }
178 }
179
180 void db_destroy_stream( MSIDATABASE *db, LPCWSTR stname )
181 {
182 MSISTREAM *stream, *stream2;
183
184 LIST_FOR_EACH_ENTRY_SAFE( stream, stream2, &db->streams, MSISTREAM, entry )
185 {
186 HRESULT r;
187 STATSTG stat;
188
189 r = IStream_Stat( stream->stm, &stat, 0 );
190 if (FAILED(r))
191 {
192 WARN("failed to stat stream r = %08x\n", r);
193 continue;
194 }
195
196 if (!strcmpW( stname, stat.pwcsName ))
197 {
198 TRACE("destroying %s\n", debugstr_w(stname));
199
200 list_remove( &stream->entry );
201 IStream_Release( stream->stm );
202 msi_free( stream );
203 IStorage_DestroyElement( db->storage, stname );
204 CoTaskMemFree( stat.pwcsName );
205 break;
206 }
207 CoTaskMemFree( stat.pwcsName );
208 }
209 }
210
211 static void free_streams( MSIDATABASE *db )
212 {
213 while( !list_empty( &db->streams ) )
214 {
215 MSISTREAM *s = LIST_ENTRY( list_head( &db->streams ),
216 MSISTREAM, entry );
217 list_remove( &s->entry );
218 IStream_Release( s->stm );
219 msi_free( s );
220 }
221 }
222
223 void append_storage_to_db( MSIDATABASE *db, IStorage *stg )
224 {
225 MSITRANSFORM *t;
226
227 t = msi_alloc( sizeof *t );
228 t->stg = stg;
229 IStorage_AddRef( stg );
230 list_add_head( &db->transforms, &t->entry );
231
232 /* the transform may add or replace streams */
233 free_streams( db );
234 }
235
236 static VOID MSI_CloseDatabase( MSIOBJECTHDR *arg )
237 {
238 MSIDATABASE *db = (MSIDATABASE *) arg;
239
240 msi_free(db->path);
241 free_cached_tables( db );
242 free_streams( db );
243 free_transforms( db );
244 msi_destroy_stringtable( db->strings );
245 IStorage_Release( db->storage );
246 if (db->deletefile)
247 {
248 DeleteFileW( db->deletefile );
249 msi_free( db->deletefile );
250 }
251 if (db->localfile)
252 {
253 DeleteFileW( db->localfile );
254 msi_free( db->localfile );
255 }
256 }
257
258 UINT MSI_OpenDatabaseW(LPCWSTR szDBPath, LPCWSTR szPersist, MSIDATABASE **pdb)
259 {
260 IStorage *stg = NULL;
261 HRESULT r;
262 MSIDATABASE *db = NULL;
263 UINT ret = ERROR_FUNCTION_FAILED;
264 LPCWSTR szMode, save_path;
265 STATSTG stat;
266 BOOL created = FALSE, patch = FALSE;
267 WCHAR path[MAX_PATH];
268
269 static const WCHAR szTables[] = { '_','T','a','b','l','e','s',0 };
270
271 TRACE("%s %s\n",debugstr_w(szDBPath),debugstr_w(szPersist) );
272
273 if( !pdb )
274 return ERROR_INVALID_PARAMETER;
275
276 if (szPersist - MSIDBOPEN_PATCHFILE >= MSIDBOPEN_READONLY &&
277 szPersist - MSIDBOPEN_PATCHFILE <= MSIDBOPEN_CREATEDIRECT)
278 {
279 TRACE("Database is a patch\n");
280 szPersist -= MSIDBOPEN_PATCHFILE;
281 patch = TRUE;
282 }
283
284 save_path = szDBPath;
285 szMode = szPersist;
286 if( !IS_INTMSIDBOPEN(szPersist) )
287 {
288 if (!CopyFileW( szDBPath, szPersist, FALSE ))
289 return ERROR_OPEN_FAILED;
290
291 szDBPath = szPersist;
292 szPersist = MSIDBOPEN_TRANSACT;
293 created = TRUE;
294 }
295
296 if( szPersist == MSIDBOPEN_READONLY )
297 {
298 r = StgOpenStorage( szDBPath, NULL,
299 STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
300 }
301 else if( szPersist == MSIDBOPEN_CREATE || szPersist == MSIDBOPEN_CREATEDIRECT )
302 {
303 /* FIXME: MSIDBOPEN_CREATE should case STGM_TRANSACTED flag to be
304 * used here: */
305 r = StgCreateDocfile( szDBPath,
306 STGM_CREATE|STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &stg);
307 if( r == ERROR_SUCCESS )
308 {
309 IStorage_SetClass( stg, patch ? &CLSID_MsiPatch : &CLSID_MsiDatabase );
310 /* create the _Tables stream */
311 r = write_stream_data(stg, szTables, NULL, 0, TRUE);
312 if (SUCCEEDED(r))
313 r = msi_init_string_table( stg );
314 }
315 created = TRUE;
316 }
317 else if( szPersist == MSIDBOPEN_TRANSACT )
318 {
319 /* FIXME: MSIDBOPEN_TRANSACT should case STGM_TRANSACTED flag to be
320 * used here: */
321 r = StgOpenStorage( szDBPath, NULL,
322 STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
323 }
324 else if( szPersist == MSIDBOPEN_DIRECT )
325 {
326 r = StgOpenStorage( szDBPath, NULL,
327 STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
328 }
329 else
330 {
331 ERR("unknown flag %p\n",szPersist);
332 return ERROR_INVALID_PARAMETER;
333 }
334
335 if( FAILED( r ) || !stg )
336 {
337 FIXME("open failed r = %08x for %s\n", r, debugstr_w(szDBPath));
338 return ERROR_FUNCTION_FAILED;
339 }
340
341 r = IStorage_Stat( stg, &stat, STATFLAG_NONAME );
342 if( FAILED( r ) )
343 {
344 FIXME("Failed to stat storage\n");
345 goto end;
346 }
347
348 if ( !IsEqualGUID( &stat.clsid, &CLSID_MsiDatabase ) &&
349 !IsEqualGUID( &stat.clsid, &CLSID_MsiPatch ) &&
350 !IsEqualGUID( &stat.clsid, &CLSID_MsiTransform ) )
351 {
352 ERR("storage GUID is not a MSI database GUID %s\n",
353 debugstr_guid(&stat.clsid) );
354 goto end;
355 }
356
357 if ( patch && !IsEqualGUID( &stat.clsid, &CLSID_MsiPatch ) )
358 {
359 ERR("storage GUID is not the MSI patch GUID %s\n",
360 debugstr_guid(&stat.clsid) );
361 ret = ERROR_OPEN_FAILED;
362 goto end;
363 }
364
365 db = alloc_msiobject( MSIHANDLETYPE_DATABASE, sizeof (MSIDATABASE),
366 MSI_CloseDatabase );
367 if( !db )
368 {
369 FIXME("Failed to allocate a handle\n");
370 goto end;
371 }
372
373 if (!strchrW( save_path, '\\' ))
374 {
375 GetCurrentDirectoryW( MAX_PATH, path );
376 lstrcatW( path, szBackSlash );
377 lstrcatW( path, save_path );
378 }
379 else
380 lstrcpyW( path, save_path );
381
382 db->path = strdupW( path );
383
384 if( TRACE_ON( msi ) )
385 enum_stream_names( stg );
386
387 db->storage = stg;
388 db->mode = szMode;
389 if (created)
390 db->deletefile = strdupW( szDBPath );
391 list_init( &db->tables );
392 list_init( &db->transforms );
393 list_init( &db->streams );
394
395 db->strings = msi_load_string_table( stg, &db->bytes_per_strref );
396 if( !db->strings )
397 goto end;
398
399 ret = ERROR_SUCCESS;
400
401 msiobj_addref( &db->hdr );
402 IStorage_AddRef( stg );
403 *pdb = db;
404
405 end:
406 if( db )
407 msiobj_release( &db->hdr );
408 if( stg )
409 IStorage_Release( stg );
410
411 return ret;
412 }
413
414 UINT WINAPI MsiOpenDatabaseW(LPCWSTR szDBPath, LPCWSTR szPersist, MSIHANDLE *phDB)
415 {
416 MSIDATABASE *db;
417 UINT ret;
418
419 TRACE("%s %s %p\n",debugstr_w(szDBPath),debugstr_w(szPersist), phDB);
420
421 ret = MSI_OpenDatabaseW( szDBPath, szPersist, &db );
422 if( ret == ERROR_SUCCESS )
423 {
424 *phDB = alloc_msihandle( &db->hdr );
425 if (! *phDB)
426 ret = ERROR_NOT_ENOUGH_MEMORY;
427 msiobj_release( &db->hdr );
428 }
429
430 return ret;
431 }
432
433 UINT WINAPI MsiOpenDatabaseA(LPCSTR szDBPath, LPCSTR szPersist, MSIHANDLE *phDB)
434 {
435 HRESULT r = ERROR_FUNCTION_FAILED;
436 LPWSTR szwDBPath = NULL, szwPersist = NULL;
437
438 TRACE("%s %s %p\n", debugstr_a(szDBPath), debugstr_a(szPersist), phDB);
439
440 if( szDBPath )
441 {
442 szwDBPath = strdupAtoW( szDBPath );
443 if( !szwDBPath )
444 goto end;
445 }
446
447 if( !IS_INTMSIDBOPEN(szPersist) )
448 {
449 szwPersist = strdupAtoW( szPersist );
450 if( !szwPersist )
451 goto end;
452 }
453 else
454 szwPersist = (LPWSTR)(DWORD_PTR)szPersist;
455
456 r = MsiOpenDatabaseW( szwDBPath, szwPersist, phDB );
457
458 end:
459 if( !IS_INTMSIDBOPEN(szPersist) )
460 msi_free( szwPersist );
461 msi_free( szwDBPath );
462
463 return r;
464 }
465
466 static LPWSTR msi_read_text_archive(LPCWSTR path)
467 {
468 HANDLE file;
469 LPSTR data = NULL;
470 LPWSTR wdata = NULL;
471 DWORD read, size = 0;
472
473 file = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
474 if (file == INVALID_HANDLE_VALUE)
475 return NULL;
476
477 size = GetFileSize( file, NULL );
478 data = msi_alloc( size + 1 );
479 if (!data)
480 goto done;
481
482 if (!ReadFile( file, data, size, &read, NULL ))
483 goto done;
484
485 data[size] = '\0';
486 wdata = strdupAtoW( data );
487
488 done:
489 CloseHandle( file );
490 msi_free( data );
491 return wdata;
492 }
493
494 static void msi_parse_line(LPWSTR *line, LPWSTR **entries, DWORD *num_entries)
495 {
496 LPWSTR ptr = *line, save;
497 DWORD i, count = 1;
498
499 *entries = NULL;
500
501 /* stay on this line */
502 while (*ptr && *ptr != '\n')
503 {
504 /* entries are separated by tabs */
505 if (*ptr == '\t')
506 count++;
507
508 ptr++;
509 }
510
511 *entries = msi_alloc(count * sizeof(LPWSTR));
512 if (!*entries)
513 return;
514
515 /* store pointers into the data */
516 for (i = 0, ptr = *line; i < count; i++)
517 {
518 while (*ptr && *ptr == '\r') ptr++;
519 save = ptr;
520
521 while (*ptr && *ptr != '\t' && *ptr != '\n' && *ptr != '\r') ptr++;
522
523 /* NULL-separate the data */
524 if (*ptr == '\n' || *ptr == '\r')
525 {
526 while (*ptr == '\n' || *ptr == '\r')
527 *(ptr++) = '\0';
528 }
529 else if (*ptr)
530 *ptr++ = '\0';
531
532 (*entries)[i] = save;
533 }
534
535 /* move to the next line if there's more, else EOF */
536 *line = ptr;
537
538 if (num_entries)
539 *num_entries = count;
540 }
541
542 static LPWSTR msi_build_createsql_prelude(LPWSTR table)
543 {
544 LPWSTR prelude;
545 DWORD size;
546
547 static const WCHAR create_fmt[] = {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','%','s','`',' ','(',' ',0};
548
549 size = sizeof(create_fmt)/sizeof(create_fmt[0]) + lstrlenW(table) - 2;
550 prelude = msi_alloc(size * sizeof(WCHAR));
551 if (!prelude)
552 return NULL;
553
554 sprintfW(prelude, create_fmt, table);
555 return prelude;
556 }
557
558 static LPWSTR msi_build_createsql_columns(LPWSTR *columns_data, LPWSTR *types, DWORD num_columns)
559 {
560 LPWSTR columns, p;
561 LPCWSTR type;
562 DWORD sql_size = 1, i, len;
563 WCHAR expanded[128], *ptr;
564 WCHAR size[10], comma[2], extra[30];
565
566 static const WCHAR column_fmt[] = {'`','%','s','`',' ','%','s','%','s','%','s','%','s',' ',0};
567 static const WCHAR size_fmt[] = {'(','%','s',')',0};
568 static const WCHAR type_char[] = {'C','H','A','R',0};
569 static const WCHAR type_int[] = {'I','N','T',0};
570 static const WCHAR type_long[] = {'L','O','N','G',0};
571 static const WCHAR type_object[] = {'O','B','J','E','C','T',0};
572 static const WCHAR type_notnull[] = {' ','N','O','T',' ','N','U','L','L',0};
573 static const WCHAR localizable[] = {' ','L','O','C','A','L','I','Z','A','B','L','E',0};
574
575 columns = msi_alloc_zero(sql_size * sizeof(WCHAR));
576 if (!columns)
577 return NULL;
578
579 for (i = 0; i < num_columns; i++)
580 {
581 type = NULL;
582 comma[1] = size[0] = extra[0] = '\0';
583
584 if (i == num_columns - 1)
585 comma[0] = '\0';
586 else
587 comma[0] = ',';
588
589 ptr = &types[i][1];
590 len = atolW(ptr);
591 extra[0] = '\0';
592
593 switch (types[i][0])
594 {
595 case 'l':
596 lstrcpyW(extra, type_notnull);
597 case 'L':
598 lstrcatW(extra, localizable);
599 type = type_char;
600 sprintfW(size, size_fmt, ptr);
601 break;
602 case 's':
603 lstrcpyW(extra, type_notnull);
604 case 'S':
605 type = type_char;
606 sprintfW(size, size_fmt, ptr);
607 break;
608 case 'i':
609 lstrcpyW(extra, type_notnull);
610 case 'I':
611 if (len <= 2)
612 type = type_int;
613 else if (len == 4)
614 type = type_long;
615 else
616 {
617 WARN("invalid int width %u\n", len);
618 msi_free(columns);
619 return NULL;
620 }
621 break;
622 case 'v':
623 lstrcpyW(extra, type_notnull);
624 case 'V':
625 type = type_object;
626 break;
627 default:
628 ERR("Unknown type: %c\n", types[i][0]);
629 msi_free(columns);
630 return NULL;
631 }
632
633 sprintfW(expanded, column_fmt, columns_data[i], type, size, extra, comma);
634 sql_size += lstrlenW(expanded);
635
636 p = msi_realloc(columns, sql_size * sizeof(WCHAR));
637 if (!p)
638 {
639 msi_free(columns);
640 return NULL;
641 }
642 columns = p;
643
644 lstrcatW(columns, expanded);
645 }
646
647 return columns;
648 }
649
650 static LPWSTR msi_build_createsql_postlude(LPWSTR *primary_keys, DWORD num_keys)
651 {
652 LPWSTR postlude, keys, ptr;
653 DWORD size, key_size, i;
654
655 static const WCHAR key_fmt[] = {'`','%','s','`',',',' ',0};
656 static const WCHAR postlude_fmt[] = {'P','R','I','M','A','R','Y',' ','K','E','Y',' ','%','s',')',0};
657
658 for (i = 0, size = 1; i < num_keys; i++)
659 size += lstrlenW(key_fmt) + lstrlenW(primary_keys[i]) - 2;
660
661 keys = msi_alloc(size * sizeof(WCHAR));
662 if (!keys)
663 return NULL;
664
665 for (i = 0, ptr = keys; i < num_keys; i++)
666 {
667 key_size = lstrlenW(key_fmt) + lstrlenW(primary_keys[i]) -2;
668 sprintfW(ptr, key_fmt, primary_keys[i]);
669 ptr += key_size;
670 }
671
672 /* remove final ', ' */
673 *(ptr - 2) = '\0';
674
675 size = lstrlenW(postlude_fmt) + size - 1;
676 postlude = msi_alloc(size * sizeof(WCHAR));
677 if (!postlude)
678 goto done;
679
680 sprintfW(postlude, postlude_fmt, keys);
681
682 done:
683 msi_free(keys);
684 return postlude;
685 }
686
687 static UINT msi_add_table_to_db(MSIDATABASE *db, LPWSTR *columns, LPWSTR *types, LPWSTR *labels, DWORD num_labels, DWORD num_columns)
688 {
689 UINT r = ERROR_OUTOFMEMORY;
690 DWORD size;
691 MSIQUERY *view;
692 LPWSTR create_sql = NULL;
693 LPWSTR prelude, columns_sql, postlude;
694
695 prelude = msi_build_createsql_prelude(labels[0]);
696 columns_sql = msi_build_createsql_columns(columns, types, num_columns);
697 postlude = msi_build_createsql_postlude(labels + 1, num_labels - 1); /* skip over table name */
698
699 if (!prelude || !columns_sql || !postlude)
700 goto done;
701
702 size = lstrlenW(prelude) + lstrlenW(columns_sql) + lstrlenW(postlude) + 1;
703 create_sql = msi_alloc(size * sizeof(WCHAR));
704 if (!create_sql)
705 goto done;
706
707 lstrcpyW(create_sql, prelude);
708 lstrcatW(create_sql, columns_sql);
709 lstrcatW(create_sql, postlude);
710
711 r = MSI_DatabaseOpenViewW( db, create_sql, &view );
712 if (r != ERROR_SUCCESS)
713 goto done;
714
715 r = MSI_ViewExecute(view, NULL);
716 MSI_ViewClose(view);
717 msiobj_release(&view->hdr);
718
719 done:
720 msi_free(prelude);
721 msi_free(columns_sql);
722 msi_free(postlude);
723 msi_free(create_sql);
724 return r;
725 }
726
727 static LPWSTR msi_import_stream_filename(LPCWSTR path, LPCWSTR name)
728 {
729 DWORD len;
730 LPWSTR fullname, ptr;
731
732 len = lstrlenW(path) + lstrlenW(name) + 1;
733 fullname = msi_alloc(len*sizeof(WCHAR));
734 if (!fullname)
735 return NULL;
736
737 lstrcpyW( fullname, path );
738
739 /* chop off extension from path */
740 ptr = strrchrW(fullname, '.');
741 if (!ptr)
742 {
743 msi_free (fullname);
744 return NULL;
745 }
746 *ptr++ = '\\';
747 lstrcpyW( ptr, name );
748 return fullname;
749 }
750
751 static UINT construct_record(DWORD num_columns, LPWSTR *types,
752 LPWSTR *data, LPWSTR path, MSIRECORD **rec)
753 {
754 UINT i;
755
756 *rec = MSI_CreateRecord(num_columns);
757 if (!*rec)
758 return ERROR_OUTOFMEMORY;
759
760 for (i = 0; i < num_columns; i++)
761 {
762 switch (types[i][0])
763 {
764 case 'L': case 'l': case 'S': case 's':
765 MSI_RecordSetStringW(*rec, i + 1, data[i]);
766 break;
767 case 'I': case 'i':
768 if (*data[i])
769 MSI_RecordSetInteger(*rec, i + 1, atoiW(data[i]));
770 break;
771 case 'V': case 'v':
772 if (*data[i])
773 {
774 UINT r;
775 LPWSTR file = msi_import_stream_filename(path, data[i]);
776 if (!file)
777 return ERROR_FUNCTION_FAILED;
778
779 r = MSI_RecordSetStreamFromFileW(*rec, i + 1, file);
780 msi_free (file);
781 if (r != ERROR_SUCCESS)
782 return ERROR_FUNCTION_FAILED;
783 }
784 break;
785 default:
786 ERR("Unhandled column type: %c\n", types[i][0]);
787 msiobj_release(&(*rec)->hdr);
788 return ERROR_FUNCTION_FAILED;
789 }
790 }
791
792 return ERROR_SUCCESS;
793 }
794
795 static UINT msi_add_records_to_table(MSIDATABASE *db, LPWSTR *columns, LPWSTR *types,
796 LPWSTR *labels, LPWSTR **records,
797 int num_columns, int num_records,
798 LPWSTR path)
799 {
800 UINT r;
801 int i;
802 MSIQUERY *view;
803 MSIRECORD *rec;
804
805 static const WCHAR select[] = {
806 'S','E','L','E','C','T',' ','*',' ',
807 'F','R','O','M',' ','`','%','s','`',0
808 };
809
810 r = MSI_OpenQuery(db, &view, select, labels[0]);
811 if (r != ERROR_SUCCESS)
812 return r;
813
814 while (MSI_ViewFetch(view, &rec) != ERROR_NO_MORE_ITEMS)
815 {
816 r = MSI_ViewModify(view, MSIMODIFY_DELETE, rec);
817 msiobj_release(&rec->hdr);
818 if (r != ERROR_SUCCESS)
819 goto done;
820 }
821
822 for (i = 0; i < num_records; i++)
823 {
824 r = construct_record(num_columns, types, records[i], path, &rec);
825 if (r != ERROR_SUCCESS)
826 goto done;
827
828 r = MSI_ViewModify(view, MSIMODIFY_INSERT, rec);
829 if (r != ERROR_SUCCESS)
830 {
831 msiobj_release(&rec->hdr);
832 goto done;
833 }
834
835 msiobj_release(&rec->hdr);
836 }
837
838 done:
839 msiobj_release(&view->hdr);
840 return r;
841 }
842
843 static UINT MSI_DatabaseImport(MSIDATABASE *db, LPCWSTR folder, LPCWSTR file)
844 {
845 UINT r;
846 DWORD len, i;
847 DWORD num_labels, num_types;
848 DWORD num_columns, num_records = 0;
849 LPWSTR *columns, *types, *labels;
850 LPWSTR path, ptr, data;
851 LPWSTR **records = NULL;
852 LPWSTR **temp_records;
853
854 static const WCHAR suminfo[] =
855 {'_','S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',0};
856
857 TRACE("%p %s %s\n", db, debugstr_w(folder), debugstr_w(file) );
858
859 if( folder == NULL || file == NULL )
860 return ERROR_INVALID_PARAMETER;
861
862 len = lstrlenW(folder) + lstrlenW(szBackSlash) + lstrlenW(file) + 1;
863 path = msi_alloc( len * sizeof(WCHAR) );
864 if (!path)
865 return ERROR_OUTOFMEMORY;
866
867 lstrcpyW( path, folder );
868 lstrcatW( path, szBackSlash );
869 lstrcatW( path, file );
870
871 data = msi_read_text_archive( path );
872
873 ptr = data;
874 msi_parse_line( &ptr, &columns, &num_columns );
875 msi_parse_line( &ptr, &types, &num_types );
876 msi_parse_line( &ptr, &labels, &num_labels );
877
878 if (num_columns != num_types)
879 {
880 r = ERROR_FUNCTION_FAILED;
881 goto done;
882 }
883
884 records = msi_alloc(sizeof(LPWSTR *));
885 if (!records)
886 {
887 r = ERROR_OUTOFMEMORY;
888 goto done;
889 }
890
891 /* read in the table records */
892 while (*ptr)
893 {
894 msi_parse_line( &ptr, &records[num_records], NULL );
895
896 num_records++;
897 temp_records = msi_realloc(records, (num_records + 1) * sizeof(LPWSTR *));
898 if (!temp_records)
899 {
900 r = ERROR_OUTOFMEMORY;
901 goto done;
902 }
903 records = temp_records;
904 }
905
906 if (!strcmpW(labels[0], suminfo))
907 {
908 r = msi_add_suminfo( db, records, num_records, num_columns );
909 if (r != ERROR_SUCCESS)
910 {
911 r = ERROR_FUNCTION_FAILED;
912 goto done;
913 }
914 }
915 else
916 {
917 if (!TABLE_Exists(db, labels[0]))
918 {
919 r = msi_add_table_to_db( db, columns, types, labels, num_labels, num_columns );
920 if (r != ERROR_SUCCESS)
921 {
922 r = ERROR_FUNCTION_FAILED;
923 goto done;
924 }
925 }
926
927 r = msi_add_records_to_table( db, columns, types, labels, records, num_columns, num_records, path );
928 }
929
930 done:
931 msi_free(path);
932 msi_free(data);
933 msi_free(columns);
934 msi_free(types);
935 msi_free(labels);
936
937 for (i = 0; i < num_records; i++)
938 msi_free(records[i]);
939
940 msi_free(records);
941
942 return r;
943 }
944
945 UINT WINAPI MsiDatabaseImportW(MSIHANDLE handle, LPCWSTR szFolder, LPCWSTR szFilename)
946 {
947 MSIDATABASE *db;
948 UINT r;
949
950 TRACE("%x %s %s\n",handle,debugstr_w(szFolder), debugstr_w(szFilename));
951
952 db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
953 if( !db )
954 {
955 IWineMsiRemoteDatabase *remote_database;
956
957 remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( handle );
958 if ( !remote_database )
959 return ERROR_INVALID_HANDLE;
960
961 IWineMsiRemoteDatabase_Release( remote_database );
962 WARN("MsiDatabaseImport not allowed during a custom action!\n");
963
964 return ERROR_SUCCESS;
965 }
966
967 r = MSI_DatabaseImport( db, szFolder, szFilename );
968 msiobj_release( &db->hdr );
969 return r;
970 }
971
972 UINT WINAPI MsiDatabaseImportA( MSIHANDLE handle,
973 LPCSTR szFolder, LPCSTR szFilename )
974 {
975 LPWSTR path = NULL, file = NULL;
976 UINT r = ERROR_OUTOFMEMORY;
977
978 TRACE("%x %s %s\n", handle, debugstr_a(szFolder), debugstr_a(szFilename));
979
980 if( szFolder )
981 {
982 path = strdupAtoW( szFolder );
983 if( !path )
984 goto end;
985 }
986
987 if( szFilename )
988 {
989 file = strdupAtoW( szFilename );
990 if( !file )
991 goto end;
992 }
993
994 r = MsiDatabaseImportW( handle, path, file );
995
996 end:
997 msi_free( path );
998 msi_free( file );
999
1000 return r;
1001 }
1002
1003 static UINT msi_export_record( HANDLE handle, MSIRECORD *row, UINT start )
1004 {
1005 UINT i, count, len, r = ERROR_SUCCESS;
1006 const char *sep;
1007 char *buffer;
1008 DWORD sz;
1009
1010 len = 0x100;
1011 buffer = msi_alloc( len );
1012 if ( !buffer )
1013 return ERROR_OUTOFMEMORY;
1014
1015 count = MSI_RecordGetFieldCount( row );
1016 for ( i=start; i<=count; i++ )
1017 {
1018 sz = len;
1019 r = MSI_RecordGetStringA( row, i, buffer, &sz );
1020 if (r == ERROR_MORE_DATA)
1021 {
1022 char *p = msi_realloc( buffer, sz + 1 );
1023 if (!p)
1024 break;
1025 len = sz + 1;
1026 buffer = p;
1027 }
1028 sz = len;
1029 r = MSI_RecordGetStringA( row, i, buffer, &sz );
1030 if (r != ERROR_SUCCESS)
1031 break;
1032
1033 if (!WriteFile( handle, buffer, sz, &sz, NULL ))
1034 {
1035 r = ERROR_FUNCTION_FAILED;
1036 break;
1037 }
1038
1039 sep = (i < count) ? "\t" : "\r\n";
1040 if (!WriteFile( handle, sep, strlen(sep), &sz, NULL ))
1041 {
1042 r = ERROR_FUNCTION_FAILED;
1043 break;
1044 }
1045 }
1046 msi_free( buffer );
1047 return r;
1048 }
1049
1050 static UINT msi_export_row( MSIRECORD *row, void *arg )
1051 {
1052 return msi_export_record( arg, row, 1 );
1053 }
1054
1055 static UINT msi_export_forcecodepage( HANDLE handle )
1056 {
1057 DWORD sz;
1058
1059 static const char data[] = "\r\n\r\n0\t_ForceCodepage\r\n";
1060
1061 FIXME("Read the codepage from the strings table!\n");
1062
1063 sz = lstrlenA(data) + 1;
1064 if (!WriteFile(handle, data, sz, &sz, NULL))
1065 return ERROR_FUNCTION_FAILED;
1066
1067 return ERROR_SUCCESS;
1068 }
1069
1070 static UINT MSI_DatabaseExport( MSIDATABASE *db, LPCWSTR table,
1071 LPCWSTR folder, LPCWSTR file )
1072 {
1073 static const WCHAR query[] = {
1074 's','e','l','e','c','t',' ','*',' ','f','r','o','m',' ','%','s',0 };
1075 static const WCHAR forcecodepage[] = {
1076 '_','F','o','r','c','e','C','o','d','e','p','a','g','e',0 };
1077 MSIRECORD *rec = NULL;
1078 MSIQUERY *view = NULL;
1079 LPWSTR filename;
1080 HANDLE handle;
1081 UINT len, r;
1082
1083 TRACE("%p %s %s %s\n", db, debugstr_w(table),
1084 debugstr_w(folder), debugstr_w(file) );
1085
1086 if( folder == NULL || file == NULL )
1087 return ERROR_INVALID_PARAMETER;
1088
1089 len = lstrlenW(folder) + lstrlenW(file) + 2;
1090 filename = msi_alloc(len * sizeof (WCHAR));
1091 if (!filename)
1092 return ERROR_OUTOFMEMORY;
1093
1094 lstrcpyW( filename, folder );
1095 lstrcatW( filename, szBackSlash );
1096 lstrcatW( filename, file );
1097
1098 handle = CreateFileW( filename, GENERIC_READ | GENERIC_WRITE, 0,
1099 NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1100 msi_free( filename );
1101 if (handle == INVALID_HANDLE_VALUE)
1102 return ERROR_FUNCTION_FAILED;
1103
1104 if (!lstrcmpW( table, forcecodepage ))
1105 {
1106 r = msi_export_forcecodepage( handle );
1107 goto done;
1108 }
1109
1110 r = MSI_OpenQuery( db, &view, query, table );
1111 if (r == ERROR_SUCCESS)
1112 {
1113 /* write out row 1, the column names */
1114 r = MSI_ViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1115 if (r == ERROR_SUCCESS)
1116 {
1117 msi_export_record( handle, rec, 1 );
1118 msiobj_release( &rec->hdr );
1119 }
1120
1121 /* write out row 2, the column types */
1122 r = MSI_ViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1123 if (r == ERROR_SUCCESS)
1124 {
1125 msi_export_record( handle, rec, 1 );
1126 msiobj_release( &rec->hdr );
1127 }
1128
1129 /* write out row 3, the table name + keys */
1130 r = MSI_DatabaseGetPrimaryKeys( db, table, &rec );
1131 if (r == ERROR_SUCCESS)
1132 {
1133 MSI_RecordSetStringW( rec, 0, table );
1134 msi_export_record( handle, rec, 0 );
1135 msiobj_release( &rec->hdr );
1136 }
1137
1138 /* write out row 4 onwards, the data */
1139 r = MSI_IterateRecords( view, 0, msi_export_row, handle );
1140 msiobj_release( &view->hdr );
1141 }
1142
1143 done:
1144 CloseHandle( handle );
1145 return r;
1146 }
1147
1148 /***********************************************************************
1149 * MsiExportDatabaseW [MSI.@]
1150 *
1151 * Writes a file containing the table data as tab separated ASCII.
1152 *
1153 * The format is as follows:
1154 *
1155 * row1 : colname1 <tab> colname2 <tab> .... colnameN <cr> <lf>
1156 * row2 : coltype1 <tab> coltype2 <tab> .... coltypeN <cr> <lf>
1157 * row3 : tablename <tab> key1 <tab> key2 <tab> ... keyM <cr> <lf>
1158 *
1159 * Followed by the data, starting at row 1 with one row per line
1160 *
1161 * row4 : data <tab> data <tab> data <tab> ... data <cr> <lf>
1162 */
1163 UINT WINAPI MsiDatabaseExportW( MSIHANDLE handle, LPCWSTR szTable,
1164 LPCWSTR szFolder, LPCWSTR szFilename )
1165 {
1166 MSIDATABASE *db;
1167 UINT r;
1168
1169 TRACE("%x %s %s %s\n", handle, debugstr_w(szTable),
1170 debugstr_w(szFolder), debugstr_w(szFilename));
1171
1172 db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
1173 if( !db )
1174 {
1175 IWineMsiRemoteDatabase *remote_database;
1176
1177 remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( handle );
1178 if ( !remote_database )
1179 return ERROR_INVALID_HANDLE;
1180
1181 IWineMsiRemoteDatabase_Release( remote_database );
1182 WARN("MsiDatabaseExport not allowed during a custom action!\n");
1183
1184 return ERROR_SUCCESS;
1185 }
1186
1187 r = MSI_DatabaseExport( db, szTable, szFolder, szFilename );
1188 msiobj_release( &db->hdr );
1189 return r;
1190 }
1191
1192 UINT WINAPI MsiDatabaseExportA( MSIHANDLE handle, LPCSTR szTable,
1193 LPCSTR szFolder, LPCSTR szFilename )
1194 {
1195 LPWSTR path = NULL, file = NULL, table = NULL;
1196 UINT r = ERROR_OUTOFMEMORY;
1197
1198 TRACE("%x %s %s %s\n", handle, debugstr_a(szTable),
1199 debugstr_a(szFolder), debugstr_a(szFilename));
1200
1201 if( szTable )
1202 {
1203 table = strdupAtoW( szTable );
1204 if( !table )
1205 goto end;
1206 }
1207
1208 if( szFolder )
1209 {
1210 path = strdupAtoW( szFolder );
1211 if( !path )
1212 goto end;
1213 }
1214
1215 if( szFilename )
1216 {
1217 file = strdupAtoW( szFilename );
1218 if( !file )
1219 goto end;
1220 }
1221
1222 r = MsiDatabaseExportW( handle, table, path, file );
1223
1224 end:
1225 msi_free( table );
1226 msi_free( path );
1227 msi_free( file );
1228
1229 return r;
1230 }
1231
1232 UINT WINAPI MsiDatabaseMergeA(MSIHANDLE hDatabase, MSIHANDLE hDatabaseMerge,
1233 LPCSTR szTableName)
1234 {
1235 UINT r;
1236 LPWSTR table;
1237
1238 TRACE("(%d, %d, %s)\n", hDatabase, hDatabaseMerge,
1239 debugstr_a(szTableName));
1240
1241 table = strdupAtoW(szTableName);
1242 r = MsiDatabaseMergeW(hDatabase, hDatabaseMerge, table);
1243
1244 msi_free(table);
1245 return r;
1246 }
1247
1248 typedef struct _tagMERGETABLE
1249 {
1250 struct list entry;
1251 struct list rows;
1252 LPWSTR name;
1253 DWORD numconflicts;
1254 LPWSTR *columns;
1255 DWORD numcolumns;
1256 LPWSTR *types;
1257 DWORD numtypes;
1258 LPWSTR *labels;
1259 DWORD numlabels;
1260 } MERGETABLE;
1261
1262 typedef struct _tagMERGEROW
1263 {
1264 struct list entry;
1265 MSIRECORD *data;
1266 } MERGEROW;
1267
1268 typedef struct _tagMERGEDATA
1269 {
1270 MSIDATABASE *db;
1271 MSIDATABASE *merge;
1272 MERGETABLE *curtable;
1273 MSIQUERY *curview;
1274 struct list *tabledata;
1275 } MERGEDATA;
1276
1277 static BOOL merge_type_match(LPCWSTR type1, LPCWSTR type2)
1278 {
1279 if (((type1[0] == 'l') || (type1[0] == 's')) &&
1280 ((type2[0] == 'l') || (type2[0] == 's')))
1281 return TRUE;
1282
1283 if (((type1[0] == 'L') || (type1[0] == 'S')) &&
1284 ((type2[0] == 'L') || (type2[0] == 'S')))
1285 return TRUE;
1286
1287 return !lstrcmpW(type1, type2);
1288 }
1289
1290 static UINT merge_verify_colnames(MSIQUERY *dbview, MSIQUERY *mergeview)
1291 {
1292 MSIRECORD *dbrec, *mergerec;
1293 UINT r, i, count;
1294
1295 r = MSI_ViewGetColumnInfo(dbview, MSICOLINFO_NAMES, &dbrec);
1296 if (r != ERROR_SUCCESS)
1297 return r;
1298
1299 r = MSI_ViewGetColumnInfo(mergeview, MSICOLINFO_NAMES, &mergerec);
1300 if (r != ERROR_SUCCESS)
1301 return r;
1302
1303 count = MSI_RecordGetFieldCount(dbrec);
1304 for (i = 1; i <= count; i++)
1305 {
1306 if (!MSI_RecordGetString(mergerec, i))
1307 break;
1308
1309 if (lstrcmpW(MSI_RecordGetString(dbrec, i),
1310 MSI_RecordGetString(mergerec, i)))
1311 {
1312 r = ERROR_DATATYPE_MISMATCH;
1313 goto done;
1314 }
1315 }
1316
1317 msiobj_release(&dbrec->hdr);
1318 msiobj_release(&mergerec->hdr);
1319 dbrec = mergerec = NULL;
1320
1321 r = MSI_ViewGetColumnInfo(dbview, MSICOLINFO_TYPES, &dbrec);
1322 if (r != ERROR_SUCCESS)
1323 return r;
1324
1325 r = MSI_ViewGetColumnInfo(mergeview, MSICOLINFO_TYPES, &mergerec);
1326 if (r != ERROR_SUCCESS)
1327 return r;
1328
1329 count = MSI_RecordGetFieldCount(dbrec);
1330 for (i = 1; i <= count; i++)
1331 {
1332 if (!MSI_RecordGetString(mergerec, i))
1333 break;
1334
1335 if (!merge_type_match(MSI_RecordGetString(dbrec, i),
1336 MSI_RecordGetString(mergerec, i)))
1337 {
1338 r = ERROR_DATATYPE_MISMATCH;
1339 break;
1340 }
1341 }
1342
1343 done:
1344 msiobj_release(&dbrec->hdr);
1345 msiobj_release(&mergerec->hdr);
1346
1347 return r;
1348 }
1349
1350 static UINT merge_verify_primary_keys(MSIDATABASE *db, MSIDATABASE *mergedb,
1351 LPCWSTR table)
1352 {
1353 MSIRECORD *dbrec, *mergerec = NULL;
1354 UINT r, i, count;
1355
1356 r = MSI_DatabaseGetPrimaryKeys(db, table, &dbrec);
1357 if (r != ERROR_SUCCESS)
1358 return r;
1359
1360 r = MSI_DatabaseGetPrimaryKeys(mergedb, table, &mergerec);
1361 if (r != ERROR_SUCCESS)
1362 goto done;
1363
1364 count = MSI_RecordGetFieldCount(dbrec);
1365 if (count != MSI_RecordGetFieldCount(mergerec))
1366 {
1367 r = ERROR_DATATYPE_MISMATCH;
1368 goto done;
1369 }
1370
1371 for (i = 1; i <= count; i++)
1372 {
1373 if (lstrcmpW(MSI_RecordGetString(dbrec, i),
1374 MSI_RecordGetString(mergerec, i)))
1375 {
1376 r = ERROR_DATATYPE_MISMATCH;
1377 goto done;
1378 }
1379 }
1380
1381 done:
1382 msiobj_release(&dbrec->hdr);
1383 msiobj_release(&mergerec->hdr);
1384
1385 return r;
1386 }
1387
1388 static LPWSTR get_key_value(MSIQUERY *view, LPCWSTR key, MSIRECORD *rec)
1389 {
1390 MSIRECORD *colnames;
1391 LPWSTR str, val;
1392 UINT r, i = 0, sz = 0;
1393 int cmp;
1394
1395 r = MSI_ViewGetColumnInfo(view, MSICOLINFO_NAMES, &colnames);
1396 if (r != ERROR_SUCCESS)
1397 return NULL;
1398
1399 do
1400 {
1401 str = msi_dup_record_field(colnames, ++i);
1402 cmp = lstrcmpW(key, str);
1403 msi_free(str);
1404 } while (cmp);
1405
1406 msiobj_release(&colnames->hdr);
1407
1408 r = MSI_RecordGetStringW(rec, i, NULL, &sz);
1409 if (r != ERROR_SUCCESS)
1410 return NULL;
1411 sz++;
1412
1413 if (MSI_RecordGetString(rec, i)) /* check record field is a string */
1414 {
1415 /* quote string record fields */
1416 const WCHAR szQuote[] = {'\'', 0};
1417 sz += 2;
1418 val = msi_alloc(sz*sizeof(WCHAR));
1419 if (!val)
1420 return NULL;
1421
1422 lstrcpyW(val, szQuote);
1423 r = MSI_RecordGetStringW(rec, i, val+1, &sz);
1424 lstrcpyW(val+1+sz, szQuote);
1425 }
1426 else
1427 {
1428 /* do not quote integer record fields */
1429 val = msi_alloc(sz*sizeof(WCHAR));
1430 if (!val)
1431 return NULL;
1432
1433 r = MSI_RecordGetStringW(rec, i, val, &sz);
1434 }
1435
1436 if (r != ERROR_SUCCESS)
1437 {
1438 ERR("failed to get string!\n");
1439 msi_free(val);
1440 return NULL;
1441 }
1442
1443 return val;
1444 }
1445
1446 static LPWSTR create_diff_row_query(MSIDATABASE *merge, MSIQUERY *view,
1447 LPWSTR table, MSIRECORD *rec)
1448 {
1449 LPWSTR query = NULL, clause = NULL;
1450 LPWSTR ptr = NULL, val;
1451 LPCWSTR setptr;
1452 DWORD size = 1, oldsize;
1453 LPCWSTR key;
1454 MSIRECORD *keys;
1455 UINT r, i, count;
1456
1457 static const WCHAR keyset[] = {
1458 '`','%','s','`',' ','=',' ','%','s',' ','A','N','D',' ',0};
1459 static const WCHAR lastkeyset[] = {
1460 '`','%','s','`',' ','=',' ','%','s',' ',0};
1461 static const WCHAR fmt[] = {'S','E','L','E','C','T',' ','*',' ',
1462 'F','R','O','M',' ','`','%','s','`',' ',
1463 'W','H','E','R','E',' ','%','s',0};
1464
1465 r = MSI_DatabaseGetPrimaryKeys(merge, table, &keys);
1466 if (r != ERROR_SUCCESS)
1467 return NULL;
1468
1469 clause = msi_alloc_zero(size * sizeof(WCHAR));
1470 if (!clause)
1471 goto done;
1472
1473 ptr = clause;
1474 count = MSI_RecordGetFieldCount(keys);
1475 for (i = 1; i <= count; i++)
1476 {
1477 key = MSI_RecordGetString(keys, i);
1478 val = get_key_value(view, key, rec);
1479
1480 if (i == count)
1481 setptr = lastkeyset;
1482 else
1483 setptr = keyset;
1484
1485 oldsize = size;
1486 size += lstrlenW(setptr) + lstrlenW(key) + lstrlenW(val) - 4;
1487 clause = msi_realloc(clause, size * sizeof (WCHAR));
1488 if (!clause)
1489 {
1490 msi_free(val);
1491 goto done;
1492 }
1493
1494 ptr = clause + oldsize - 1;
1495 sprintfW(ptr, setptr, key, val);
1496 msi_free(val);
1497 }
1498
1499 size = lstrlenW(fmt) + lstrlenW(table) + lstrlenW(clause) + 1;
1500 query = msi_alloc(size * sizeof(WCHAR));
1501 if (!query)
1502 goto done;
1503
1504 sprintfW(query, fmt, table, clause);
1505
1506 done:
1507 msi_free(clause);
1508 msiobj_release(&keys->hdr);
1509 return query;
1510 }
1511
1512 static UINT merge_diff_row(MSIRECORD *rec, LPVOID param)
1513 {
1514 MERGEDATA *data = param;
1515 MERGETABLE *table = data->curtable;
1516 MERGEROW *mergerow;
1517 MSIQUERY *dbview = NULL;
1518 MSIRECORD *row = NULL;
1519 LPWSTR query = NULL;
1520 UINT r = ERROR_SUCCESS;
1521
1522 if (TABLE_Exists(data->db, table->name))
1523 {
1524 query = create_diff_row_query(data->merge, data->curview, table->name, rec);
1525 if (!query)
1526 return ERROR_OUTOFMEMORY;
1527
1528 r = MSI_DatabaseOpenViewW(data->db, query, &dbview);
1529 if (r != ERROR_SUCCESS)
1530 goto done;
1531
1532 r = MSI_ViewExecute(dbview, NULL);
1533 if (r != ERROR_SUCCESS)
1534 goto done;
1535
1536 r = MSI_ViewFetch(dbview, &row);
1537 if (r == ERROR_SUCCESS && !MSI_RecordsAreEqual(rec, row))
1538 {
1539 table->numconflicts++;
1540 goto done;
1541 }
1542 else if (r != ERROR_NO_MORE_ITEMS)
1543 goto done;
1544
1545 r = ERROR_SUCCESS;
1546 }
1547
1548 mergerow = msi_alloc(sizeof(MERGEROW));
1549 if (!mergerow)
1550 {
1551 r = ERROR_OUTOFMEMORY;
1552 goto done;
1553 }
1554
1555 mergerow->data = MSI_CloneRecord(rec);
1556 if (!mergerow->data)
1557 {
1558 r = ERROR_OUTOFMEMORY;
1559 msi_free(mergerow);
1560 goto done;
1561 }
1562
1563 list_add_tail(&table->rows, &mergerow->entry);
1564
1565 done:
1566 msi_free(query);
1567 msiobj_release(&row->hdr);
1568 msiobj_release(&dbview->hdr);
1569 return r;
1570 }
1571
1572 static UINT msi_get_table_labels(MSIDATABASE *db, LPCWSTR table, LPWSTR **labels, DWORD *numlabels)
1573 {
1574 UINT r, i, count;
1575 MSIRECORD *prec = NULL;
1576
1577 r = MSI_DatabaseGetPrimaryKeys(db, table, &prec);
1578 if (r != ERROR_SUCCESS)
1579 return r;
1580
1581 count = MSI_RecordGetFieldCount(prec);
1582 *numlabels = count + 1;
1583 *labels = msi_alloc((*numlabels)*sizeof(LPWSTR));
1584 if (!*labels)
1585 {
1586 r = ERROR_OUTOFMEMORY;
1587 goto end;
1588 }
1589
1590 (*labels)[0] = strdupW(table);
1591 for (i=1; i<=count; i++ )
1592 {
1593 (*labels)[i] = strdupW(MSI_RecordGetString(prec, i));
1594 }
1595
1596 end:
1597 msiobj_release( &prec->hdr );
1598 return r;
1599 }
1600
1601 static UINT msi_get_query_columns(MSIQUERY *query, LPWSTR **columns, DWORD *numcolumns)
1602 {
1603 UINT r, i, count;
1604 MSIRECORD *prec = NULL;
1605
1606 r = MSI_ViewGetColumnInfo(query, MSICOLINFO_NAMES, &prec);
1607 if (r != ERROR_SUCCESS)
1608 return r;
1609
1610 count = MSI_RecordGetFieldCount(prec);
1611 *columns = msi_alloc(count*sizeof(LPWSTR));
1612 if (!*columns)
1613 {
1614 r = ERROR_OUTOFMEMORY;
1615 goto end;
1616 }
1617
1618 for (i=1; i<=count; i++ )
1619 {
1620 (*columns)[i-1] = strdupW(MSI_RecordGetString(prec, i));
1621 }
1622
1623 *numcolumns = count;
1624
1625 end:
1626 msiobj_release( &prec->hdr );
1627 return r;
1628 }
1629
1630 static UINT msi_get_query_types(MSIQUERY *query, LPWSTR **types, DWORD *numtypes)
1631 {
1632 UINT r, i, count;
1633 MSIRECORD *prec = NULL;
1634
1635 r = MSI_ViewGetColumnInfo(query, MSICOLINFO_TYPES, &prec);
1636 if (r != ERROR_SUCCESS)
1637 return r;
1638
1639 count = MSI_RecordGetFieldCount(prec);
1640 *types = msi_alloc(count*sizeof(LPWSTR));
1641 if (!*types)
1642 {
1643 r = ERROR_OUTOFMEMORY;
1644 goto end;
1645 }
1646
1647 *numtypes = count;
1648 for (i=1; i<=count; i++ )
1649 {
1650 (*types)[i-1] = strdupW(MSI_RecordGetString(prec, i));
1651 }
1652
1653 end:
1654 msiobj_release( &prec->hdr );
1655 return r;
1656 }
1657
1658 static void merge_free_rows(MERGETABLE *table)
1659 {
1660 struct list *item, *cursor;
1661
1662 LIST_FOR_EACH_SAFE(item, cursor, &table->rows)
1663 {
1664 MERGEROW *row = LIST_ENTRY(item, MERGEROW, entry);
1665
1666 list_remove(&row->entry);
1667 msiobj_release(&row->data->hdr);
1668 msi_free(row);
1669 }
1670 }
1671
1672 static void free_merge_table(MERGETABLE *table)
1673 {
1674 UINT i;
1675
1676 if (table->labels != NULL)
1677 {
1678 for (i = 0; i < table->numlabels; i++)
1679 msi_free(table->labels[i]);
1680
1681 msi_free(table->labels);
1682 }
1683
1684 if (table->columns != NULL)
1685 {
1686 for (i = 0; i < table->numcolumns; i++)
1687 msi_free(table->columns[i]);
1688
1689 msi_free(table->columns);
1690 }
1691
1692 if (table->types != NULL)
1693 {
1694 for (i = 0; i < table->numtypes; i++)
1695 msi_free(table->types[i]);
1696
1697 msi_free(table->types);
1698 }
1699
1700 msi_free(table->name);
1701 merge_free_rows(table);
1702
1703 msi_free(table);
1704 }
1705
1706 static UINT msi_get_merge_table (MSIDATABASE *db, LPCWSTR name, MERGETABLE **ptable)
1707 {
1708 UINT r;
1709 MERGETABLE *table;
1710 MSIQUERY *mergeview = NULL;
1711
1712 static const WCHAR query[] = {'S','E','L','E','C','T',' ','*',' ',
1713 'F','R','O','M',' ','`','%','s','`',0};
1714
1715 table = msi_alloc_zero(sizeof(MERGETABLE));
1716 if (!table)
1717 {
1718 *ptable = NULL;
1719 return ERROR_OUTOFMEMORY;
1720 }
1721
1722 r = msi_get_table_labels(db, name, &table->labels, &table->numlabels);
1723 if (r != ERROR_SUCCESS)
1724 goto err;
1725
1726 r = MSI_OpenQuery(db, &mergeview, query, name);
1727 if (r != ERROR_SUCCESS)
1728 goto err;
1729
1730 r = msi_get_query_columns(mergeview, &table->columns, &table->numcolumns);
1731 if (r != ERROR_SUCCESS)
1732 goto err;
1733
1734 r = msi_get_query_types(mergeview, &table->types, &table->numtypes);
1735 if (r != ERROR_SUCCESS)
1736 goto err;
1737
1738 list_init(&table->rows);
1739
1740 table->name = strdupW(name);
1741 table->numconflicts = 0;
1742
1743 msiobj_release(&mergeview->hdr);
1744 *ptable = table;
1745 return ERROR_SUCCESS;
1746
1747 err:
1748 msiobj_release(&mergeview->hdr);
1749 free_merge_table(table);
1750 *ptable = NULL;
1751 return r;
1752 }
1753
1754 static UINT merge_diff_tables(MSIRECORD *rec, LPVOID param)
1755 {
1756 MERGEDATA *data = param;
1757 MERGETABLE *table;
1758 MSIQUERY *dbview = NULL;
1759 MSIQUERY *mergeview = NULL;
1760 LPCWSTR name;
1761 UINT r;
1762
1763 static const WCHAR query[] = {'S','E','L','E','C','T',' ','*',' ',
1764 'F','R','O','M',' ','`','%','s','`',0};
1765
1766 name = MSI_RecordGetString(rec, 1);
1767
1768 r = MSI_OpenQuery(data->merge, &mergeview, query, name);
1769 if (r != ERROR_SUCCESS)
1770 goto done;
1771
1772 if (TABLE_Exists(data->db, name))
1773 {
1774 r = MSI_OpenQuery(data->db, &dbview, query, name);
1775 if (r != ERROR_SUCCESS)
1776 goto done;
1777
1778 r = merge_verify_colnames(dbview, mergeview);
1779 if (r != ERROR_SUCCESS)
1780 goto done;
1781
1782 r = merge_verify_primary_keys(data->db, data->merge, name);
1783 if (r != ERROR_SUCCESS)
1784 goto done;
1785 }
1786
1787 r = msi_get_merge_table(data->merge, name, &table);
1788 if (r != ERROR_SUCCESS)
1789 goto done;
1790
1791 data->curtable = table;
1792 data->curview = mergeview;
1793 r = MSI_IterateRecords(mergeview, NULL, merge_diff_row, data);
1794 if (r != ERROR_SUCCESS)
1795 {
1796 free_merge_table(table);
1797 goto done;
1798 }
1799
1800 list_add_tail(data->tabledata, &table->entry);
1801
1802 done:
1803 msiobj_release(&dbview->hdr);
1804 msiobj_release(&mergeview->hdr);
1805 return r;
1806 }
1807
1808 static UINT gather_merge_data(MSIDATABASE *db, MSIDATABASE *merge,
1809 struct list *tabledata)
1810 {
1811 UINT r;
1812 MSIQUERY *view;
1813 MERGEDATA data;
1814
1815 static const WCHAR query[] = {'S','E','L','E','C','T',' ','*',' ',
1816 'F','R','O','M',' ','`','_','T','a','b','l','e','s','`',0};
1817
1818 r = MSI_DatabaseOpenViewW(merge, query, &view);
1819 if (r != ERROR_SUCCESS)
1820 return r;
1821
1822 data.db = db;
1823 data.merge = merge;
1824 data.tabledata = tabledata;
1825 r = MSI_IterateRecords(view, NULL, merge_diff_tables, &data);
1826
1827 msiobj_release(&view->hdr);
1828 return r;
1829 }
1830
1831 static UINT merge_table(MSIDATABASE *db, MERGETABLE *table)
1832 {
1833 UINT r;
1834 MERGEROW *row;
1835 MSIVIEW *tv;
1836
1837 if (!TABLE_Exists(db, table->name))
1838 {
1839 r = msi_add_table_to_db(db, table->columns, table->types,
1840 table->labels, table->numlabels, table->numcolumns);
1841 if (r != ERROR_SUCCESS)
1842 return ERROR_FUNCTION_FAILED;
1843 }
1844
1845 LIST_FOR_EACH_ENTRY(row, &table->rows, MERGEROW, entry)
1846 {
1847 r = TABLE_CreateView(db, table->name, &tv);
1848 if (r != ERROR_SUCCESS)
1849 return r;
1850
1851 r = tv->ops->insert_row(tv, row->data, -1, FALSE);
1852 tv->ops->delete(tv);
1853
1854 if (r != ERROR_SUCCESS)
1855 return r;
1856 }
1857
1858 return ERROR_SUCCESS;
1859 }
1860
1861 static UINT update_merge_errors(MSIDATABASE *db, LPCWSTR error,
1862 LPWSTR table, DWORD numconflicts)
1863 {
1864 UINT r;
1865 MSIQUERY *view;
1866
1867 static const WCHAR create[] = {
1868 'C','R','E','A','T','E',' ','T','A','B','L','E',' ',
1869 '`','%','s','`',' ','(','`','T','a','b','l','e','`',' ',
1870 'C','H','A','R','(','2','5','5',')',' ','N','O','T',' ',
1871 'N','U','L','L',',',' ','`','N','u','m','R','o','w','M','e','r','g','e',
1872 'C','o','n','f','l','i','c','t','s','`',' ','S','H','O','R','T',' ',
1873 'N','O','T',' ','N','U','L','L',' ','P','R','I','M','A','R','Y',' ',
1874 'K','E','Y',' ','`','T','a','b','l','e','`',')',0};
1875 static const WCHAR insert[] = {
1876 'I','N','S','E','R','T',' ','I','N','T','O',' ',
1877 '`','%','s','`',' ','(','`','T','a','b','l','e','`',',',' ',
1878 '`','N','u','m','R','o','w','M','e','r','g','e',
1879 'C','o','n','f','l','i','c','t','s','`',')',' ','V','A','L','U','E','S',
1880 ' ','(','\'','%','s','\'',',',' ','%','d',')',0};
1881
1882 if (!TABLE_Exists(db, error))
1883 {
1884 r = MSI_OpenQuery(db, &view, create, error);
1885 if (r != ERROR_SUCCESS)
1886 return r;
1887
1888 r = MSI_ViewExecute(view, NULL);
1889 msiobj_release(&view->hdr);
1890 if (r != ERROR_SUCCESS)
1891 return r;
1892 }
1893
1894 r = MSI_OpenQuery(db, &view, insert, error, table, numconflicts);
1895 if (r != ERROR_SUCCESS)
1896 return r;
1897
1898 r = MSI_ViewExecute(view, NULL);
1899 msiobj_release(&view->hdr);
1900 return r;
1901 }
1902
1903 UINT WINAPI MsiDatabaseMergeW(MSIHANDLE hDatabase, MSIHANDLE hDatabaseMerge,
1904 LPCWSTR szTableName)
1905 {
1906 struct list tabledata = LIST_INIT(tabledata);
1907 struct list *item, *cursor;
1908 MSIDATABASE *db, *merge;
1909 MERGETABLE *table;
1910 BOOL conflicts;
1911 UINT r;
1912
1913 TRACE("(%d, %d, %s)\n", hDatabase, hDatabaseMerge,
1914 debugstr_w(szTableName));
1915
1916 if (szTableName && !*szTableName)
1917 return ERROR_INVALID_TABLE;
1918
1919 db = msihandle2msiinfo(hDatabase, MSIHANDLETYPE_DATABASE);
1920 merge = msihandle2msiinfo(hDatabaseMerge, MSIHANDLETYPE_DATABASE);
1921 if (!db || !merge)
1922 {
1923 r = ERROR_INVALID_HANDLE;
1924 goto done;
1925 }
1926
1927 r = gather_merge_data(db, merge, &tabledata);
1928 if (r != ERROR_SUCCESS)
1929 goto done;
1930
1931 conflicts = FALSE;
1932 LIST_FOR_EACH_ENTRY(table, &tabledata, MERGETABLE, entry)
1933 {
1934 if (table->numconflicts)
1935 {
1936 conflicts = TRUE;
1937
1938 r = update_merge_errors(db, szTableName, table->name,
1939 table->numconflicts);
1940 if (r != ERROR_SUCCESS)
1941 break;
1942 }
1943 else
1944 {
1945 r = merge_table(db, table);
1946 if (r != ERROR_SUCCESS)
1947 break;
1948 }
1949 }
1950
1951 LIST_FOR_EACH_SAFE(item, cursor, &tabledata)
1952 {
1953 MERGETABLE *table = LIST_ENTRY(item, MERGETABLE, entry);
1954 list_remove(&table->entry);
1955 free_merge_table(table);
1956 }
1957
1958 if (conflicts)
1959 r = ERROR_FUNCTION_FAILED;
1960
1961 done:
1962 msiobj_release(&db->hdr);
1963 msiobj_release(&merge->hdr);
1964 return r;
1965 }
1966
1967 MSIDBSTATE WINAPI MsiGetDatabaseState( MSIHANDLE handle )
1968 {
1969 MSIDBSTATE ret = MSIDBSTATE_READ;
1970 MSIDATABASE *db;
1971
1972 TRACE("%d\n", handle);
1973
1974 db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
1975 if( !db )
1976 {
1977 IWineMsiRemoteDatabase *remote_database;
1978
1979 remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( handle );
1980 if ( !remote_database )
1981 return MSIDBSTATE_ERROR;
1982
1983 IWineMsiRemoteDatabase_Release( remote_database );
1984 WARN("MsiGetDatabaseState not allowed during a custom action!\n");
1985
1986 return MSIDBSTATE_READ;
1987 }
1988
1989 if (db->mode != MSIDBOPEN_READONLY )
1990 ret = MSIDBSTATE_WRITE;
1991 msiobj_release( &db->hdr );
1992
1993 return ret;
1994 }
1995
1996 typedef struct _msi_remote_database_impl {
1997 const IWineMsiRemoteDatabaseVtbl *lpVtbl;
1998 MSIHANDLE database;
1999 LONG refs;
2000 } msi_remote_database_impl;
2001
2002 static inline msi_remote_database_impl* mrd_from_IWineMsiRemoteDatabase( IWineMsiRemoteDatabase* iface )
2003 {
2004 return (msi_remote_database_impl *)iface;
2005 }
2006
2007 static HRESULT WINAPI mrd_QueryInterface( IWineMsiRemoteDatabase *iface,
2008 REFIID riid,LPVOID *ppobj)
2009 {
2010 if( IsEqualCLSID( riid, &IID_IUnknown ) ||
2011 IsEqualCLSID( riid, &IID_IWineMsiRemoteDatabase ) )
2012 {
2013 IUnknown_AddRef( iface );
2014 *ppobj = iface;
2015 return S_OK;
2016 }
2017
2018 return E_NOINTERFACE;
2019 }
2020
2021 static ULONG WINAPI mrd_AddRef( IWineMsiRemoteDatabase *iface )
2022 {
2023 msi_remote_database_impl* This = mrd_from_IWineMsiRemoteDatabase( iface );
2024
2025 return InterlockedIncrement( &This->refs );
2026 }
2027
2028 static ULONG WINAPI mrd_Release( IWineMsiRemoteDatabase *iface )
2029 {
2030 msi_remote_database_impl* This = mrd_from_IWineMsiRemoteDatabase( iface );
2031 ULONG r;
2032
2033 r = InterlockedDecrement( &This->refs );
2034 if (r == 0)
2035 {
2036 MsiCloseHandle( This->database );
2037 msi_free( This );
2038 }
2039 return r;
2040 }
2041
2042 static HRESULT WINAPI mrd_IsTablePersistent( IWineMsiRemoteDatabase *iface,
2043 LPCWSTR table, MSICONDITION *persistent )
2044 {
2045 msi_remote_database_impl *This = mrd_from_IWineMsiRemoteDatabase( iface );
2046 *persistent = MsiDatabaseIsTablePersistentW(This->database, table);
2047 return S_OK;
2048 }
2049
2050 static HRESULT WINAPI mrd_GetPrimaryKeys( IWineMsiRemoteDatabase *iface,
2051 LPCWSTR table, MSIHANDLE *keys )
2052 {
2053 msi_remote_database_impl *This = mrd_from_IWineMsiRemoteDatabase( iface );
2054 UINT r = MsiDatabaseGetPrimaryKeysW(This->database, table, keys);
2055 return HRESULT_FROM_WIN32(r);
2056 }
2057
2058 static HRESULT WINAPI mrd_GetSummaryInformation( IWineMsiRemoteDatabase *iface,
2059 UINT updatecount, MSIHANDLE *suminfo )
2060 {
2061 msi_remote_database_impl *This = mrd_from_IWineMsiRemoteDatabase( iface );
2062 UINT r = MsiGetSummaryInformationW(This->database, NULL, updatecount, suminfo);
2063 return HRESULT_FROM_WIN32(r);
2064 }
2065
2066 static HRESULT WINAPI mrd_OpenView( IWineMsiRemoteDatabase *iface,
2067 LPCWSTR query, MSIHANDLE *view )
2068 {
2069 msi_remote_database_impl *This = mrd_from_IWineMsiRemoteDatabase( iface );
2070 UINT r = MsiDatabaseOpenViewW(This->database, query, view);
2071 return HRESULT_FROM_WIN32(r);
2072 }
2073
2074 static HRESULT WINAPI mrd_SetMsiHandle( IWineMsiRemoteDatabase *iface, MSIHANDLE handle )
2075 {
2076 msi_remote_database_impl* This = mrd_from_IWineMsiRemoteDatabase( iface );
2077 This->database = handle;
2078 return S_OK;
2079 }
2080
2081 static const IWineMsiRemoteDatabaseVtbl msi_remote_database_vtbl =
2082 {
2083 mrd_QueryInterface,
2084 mrd_AddRef,
2085 mrd_Release,
2086 mrd_IsTablePersistent,
2087 mrd_GetPrimaryKeys,
2088 mrd_GetSummaryInformation,
2089 mrd_OpenView,
2090 mrd_SetMsiHandle,
2091 };
2092
2093 HRESULT create_msi_remote_database( IUnknown *pOuter, LPVOID *ppObj )
2094 {
2095 msi_remote_database_impl *This;
2096
2097 This = msi_alloc( sizeof *This );
2098 if (!This)
2099 return E_OUTOFMEMORY;
2100
2101 This->lpVtbl = &msi_remote_database_vtbl;
2102 This->database = 0;
2103 This->refs = 1;
2104
2105 *ppObj = This;
2106
2107 return S_OK;
2108 }