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