?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msi: Return ERROR_OUTOFMEMORY if calloc fails in TransformView_Create (scan-build).
[wine.git] / dlls / msi / table.c
blobe83c076ab233307dc38d19d01d6b632a1d3cff85
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2002-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 <assert.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winerror.h"
29 #include "msi.h"
30 #include "msiquery.h"
31 #include "objbase.h"
32 #include "objidl.h"
33 #include "winnls.h"
34 #include "msipriv.h"
35 #include "query.h"
36
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
40
41 #define MSITABLE_HASH_TABLE_SIZE 37
42
43 struct column_hash_entry
44 {
45 struct column_hash_entry *next;
46 UINT value;
47 UINT row;
48 };
49
50 struct column_info
51 {
52 LPCWSTR tablename;
53 UINT number;
54 LPCWSTR colname;
55 UINT type;
56 UINT offset;
57 struct column_hash_entry **hash_table;
58 };
59
60 struct tagMSITABLE
61 {
62 BYTE **data;
63 BOOL *data_persistent;
64 UINT row_count;
65 struct list entry;
66 struct column_info *colinfo;
67 UINT col_count;
68 MSICONDITION persistent;
69 LONG ref_count;
70 WCHAR name[1];
71 };
72
73 /* information for default tables */
74 static const struct column_info _Columns_cols[4] =
75 {
76 { L"_Columns", 1, L"Table", MSITYPE_VALID | MSITYPE_STRING | MSITYPE_KEY | 64, 0, NULL },
77 { L"_Columns", 2, L"Number", MSITYPE_VALID | MSITYPE_KEY | 2, 2, NULL },
78 { L"_Columns", 3, L"Name", MSITYPE_VALID | MSITYPE_STRING | 64, 4, NULL },
79 { L"_Columns", 4, L"Type", MSITYPE_VALID | 2, 6, NULL },
80 };
81
82 static const struct column_info _Tables_cols[1] =
83 {
84 { L"_Tables", 1, L"Name", MSITYPE_VALID | MSITYPE_STRING | MSITYPE_KEY | 64, 0, NULL },
85 };
86
87 #define MAX_STREAM_NAME 0x1f
88
89 static inline UINT bytes_per_column( MSIDATABASE *db, const struct column_info *col, UINT bytes_per_strref )
90 {
91 if( MSITYPE_IS_BINARY(col->type) )
92 return 2;
93
94 if( col->type & MSITYPE_STRING )
95 return bytes_per_strref;
96
97 if( (col->type & 0xff) <= 2)
98 return 2;
99
100 if( (col->type & 0xff) != 4 )
101 ERR("Invalid column size %u\n", col->type & 0xff);
102
103 return 4;
104 }
105
106 static int utf2mime(int x)
107 {
108 if( (x>='0') && (x<='9') )
109 return x-'0';
110 if( (x>='A') && (x<='Z') )
111 return x-'A'+10;
112 if( (x>='a') && (x<='z') )
113 return x-'a'+10+26;
114 if( x=='.' )
115 return 10+26+26;
116 if( x=='_' )
117 return 10+26+26+1;
118 return -1;
119 }
120
121 LPWSTR encode_streamname(BOOL bTable, LPCWSTR in)
122 {
123 DWORD count = MAX_STREAM_NAME;
124 DWORD ch, next;
125 LPWSTR out, p;
126
127 if( !bTable )
128 count = lstrlenW( in )+2;
129 if (!(out = malloc( count * sizeof(WCHAR) ))) return NULL;
130 p = out;
131
132 if( bTable )
133 {
134 *p++ = 0x4840;
135 count --;
136 }
137 while( count -- )
138 {
139 ch = *in++;
140 if( !ch )
141 {
142 *p = ch;
143 return out;
144 }
145 if( ( ch < 0x80 ) && ( utf2mime(ch) >= 0 ) )
146 {
147 ch = utf2mime(ch) + 0x4800;
148 next = *in;
149 if( next && (next<0x80) )
150 {
151 next = utf2mime(next);
152 if( next != -1 )
153 {
154 next += 0x3ffffc0;
155 ch += (next<<6);
156 in++;
157 }
158 }
159 }
160 *p++ = ch;
161 }
162 ERR("Failed to encode stream name (%s)\n",debugstr_w(in));
163 free( out );
164 return NULL;
165 }
166
167 static int mime2utf(int x)
168 {
169 if( x<10 )
170 return x + '0';
171 if( x<(10+26))
172 return x - 10 + 'A';
173 if( x<(10+26+26))
174 return x - 10 - 26 + 'a';
175 if( x == (10+26+26) )
176 return '.';
177 return '_';
178 }
179
180 BOOL decode_streamname(LPCWSTR in, LPWSTR out)
181 {
182 WCHAR ch;
183 DWORD count = 0;
184
185 while ( (ch = *in++) )
186 {
187 if( (ch >= 0x3800 ) && (ch < 0x4840 ) )
188 {
189 if( ch >= 0x4800 )
190 ch = mime2utf(ch-0x4800);
191 else
192 {
193 ch -= 0x3800;
194 *out++ = mime2utf(ch&0x3f);
195 count++;
196 ch = mime2utf((ch>>6)&0x3f);
197 }
198 }
199 *out++ = ch;
200 count++;
201 }
202 *out = 0;
203 return count;
204 }
205
206 void enum_stream_names( IStorage *stg )
207 {
208 IEnumSTATSTG *stgenum = NULL;
209 HRESULT r;
210 STATSTG stat;
211 ULONG n, count;
212 WCHAR name[0x40];
213
214 r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
215 if( FAILED( r ) )
216 return;
217
218 n = 0;
219 while( 1 )
220 {
221 count = 0;
222 r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
223 if( FAILED( r ) || !count )
224 break;
225 decode_streamname( stat.pwcsName, name );
226 TRACE( "stream %2lu -> %s %s\n", n, debugstr_w(stat.pwcsName), debugstr_w(name) );
227 CoTaskMemFree( stat.pwcsName );
228 n++;
229 }
230
231 IEnumSTATSTG_Release( stgenum );
232 }
233
234 UINT read_stream_data( IStorage *stg, LPCWSTR stname, BOOL table,
235 BYTE **pdata, UINT *psz )
236 {
237 HRESULT r;
238 UINT ret = ERROR_FUNCTION_FAILED;
239 VOID *data;
240 ULONG sz, count;
241 IStream *stm = NULL;
242 STATSTG stat;
243 LPWSTR encname;
244
245 encname = encode_streamname(table, stname);
246
247 TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
248
249 r = IStorage_OpenStream(stg, encname, NULL,
250 STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
251 free(encname);
252 if( FAILED( r ) )
253 {
254 WARN( "open stream failed r = %#lx - empty table?\n", r );
255 return ret;
256 }
257
258 r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
259 if( FAILED( r ) )
260 {
261 WARN( "open stream failed r = %#lx!\n", r );
262 goto end;
263 }
264
265 if( stat.cbSize.QuadPart >> 32 )
266 {
267 WARN("Too big!\n");
268 goto end;
269 }
270
271 sz = stat.cbSize.QuadPart;
272 data = malloc(sz);
273 if( !data )
274 {
275 WARN( "couldn't allocate memory r = %#lx!\n", r );
276 ret = ERROR_NOT_ENOUGH_MEMORY;
277 goto end;
278 }
279
280 r = IStream_Read(stm, data, sz, &count );
281 if( FAILED( r ) || ( count != sz ) )
282 {
283 free(data);
284 WARN("read stream failed r = %#lx!\n", r);
285 goto end;
286 }
287
288 *pdata = data;
289 *psz = sz;
290 ret = ERROR_SUCCESS;
291
292 end:
293 IStream_Release( stm );
294
295 return ret;
296 }
297
298 UINT write_stream_data( IStorage *stg, LPCWSTR stname,
299 LPCVOID data, UINT sz, BOOL bTable )
300 {
301 HRESULT r;
302 UINT ret = ERROR_FUNCTION_FAILED;
303 ULONG count;
304 IStream *stm = NULL;
305 ULARGE_INTEGER size;
306 LARGE_INTEGER pos;
307 LPWSTR encname;
308
309 encname = encode_streamname(bTable, stname );
310 r = IStorage_OpenStream( stg, encname, NULL,
311 STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
312 if( FAILED(r) )
313 {
314 r = IStorage_CreateStream( stg, encname,
315 STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
316 }
317 free( encname );
318 if( FAILED( r ) )
319 {
320 WARN( "open stream failed r = %#lx\n", r );
321 return ret;
322 }
323
324 size.QuadPart = sz;
325 r = IStream_SetSize( stm, size );
326 if( FAILED( r ) )
327 {
328 WARN("Failed to SetSize\n");
329 goto end;
330 }
331
332 pos.QuadPart = 0;
333 r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
334 if( FAILED( r ) )
335 {
336 WARN("Failed to Seek\n");
337 goto end;
338 }
339
340 if (sz)
341 {
342 r = IStream_Write(stm, data, sz, &count );
343 if( FAILED( r ) || ( count != sz ) )
344 {
345 WARN("Failed to Write\n");
346 goto end;
347 }
348 }
349
350 ret = ERROR_SUCCESS;
351
352 end:
353 IStream_Release( stm );
354
355 return ret;
356 }
357
358 static void free_colinfo( struct column_info *colinfo, UINT count )
359 {
360 UINT i;
361 for (i = 0; i < count; i++) free( colinfo[i].hash_table );
362 }
363
364 static void free_table( MSITABLE *table )
365 {
366 UINT i;
367 for( i=0; i<table->row_count; i++ )
368 free( table->data[i] );
369 free( table->data );
370 free( table->data_persistent );
371 free_colinfo( table->colinfo, table->col_count );
372 free( table->colinfo );
373 free( table );
374 }
375
376 static UINT table_get_row_size( MSIDATABASE *db, const struct column_info *cols, UINT count, UINT bytes_per_strref )
377 {
378 const struct column_info *last_col;
379
380 if (!count)
381 return 0;
382
383 if (bytes_per_strref != LONG_STR_BYTES)
384 {
385 UINT i, size = 0;
386 for (i = 0; i < count; i++) size += bytes_per_column( db, &cols[i], bytes_per_strref );
387 return size;
388 }
389 last_col = &cols[count - 1];
390 return last_col->offset + bytes_per_column( db, last_col, bytes_per_strref );
391 }
392
393 /* add this table to the list of cached tables in the database */
394 static UINT read_table_from_storage( MSIDATABASE *db, MSITABLE *t, IStorage *stg )
395 {
396 BYTE *rawdata = NULL;
397 UINT rawsize = 0, i, j, row_size, row_size_mem;
398
399 TRACE("%s\n",debugstr_w(t->name));
400
401 row_size = table_get_row_size( db, t->colinfo, t->col_count, db->bytes_per_strref );
402 row_size_mem = table_get_row_size( db, t->colinfo, t->col_count, LONG_STR_BYTES );
403
404 /* if we can't read the table, just assume that it's empty */
405 read_stream_data( stg, t->name, TRUE, &rawdata, &rawsize );
406 if( !rawdata )
407 return ERROR_SUCCESS;
408
409 TRACE("Read %d bytes\n", rawsize );
410
411 if( rawsize % row_size )
412 {
413 WARN("Table size is invalid %d/%d\n", rawsize, row_size );
414 goto err;
415 }
416
417 if ((t->row_count = rawsize / row_size))
418 {
419 if (!(t->data = calloc( t->row_count, sizeof(USHORT *) ))) goto err;
420 if (!(t->data_persistent = calloc( t->row_count, sizeof(BOOL) ))) goto err;
421 }
422
423 /* transpose all the data */
424 TRACE("Transposing data from %d rows\n", t->row_count );
425 for (i = 0; i < t->row_count; i++)
426 {
427 UINT ofs = 0, ofs_mem = 0;
428
429 t->data[i] = malloc( row_size_mem );
430 if( !t->data[i] )
431 goto err;
432 t->data_persistent[i] = TRUE;
433
434 for (j = 0; j < t->col_count; j++)
435 {
436 UINT m = bytes_per_column( db, &t->colinfo[j], LONG_STR_BYTES );
437 UINT n = bytes_per_column( db, &t->colinfo[j], db->bytes_per_strref );
438 UINT k;
439
440 if ( n != 2 && n != 3 && n != 4 )
441 {
442 ERR("oops - unknown column width %d\n", n);
443 goto err;
444 }
445 if (t->colinfo[j].type & MSITYPE_STRING && n < m)
446 {
447 for (k = 0; k < m; k++)
448 {
449 if (k < n)
450 t->data[i][ofs_mem + k] = rawdata[ofs * t->row_count + i * n + k];
451 else
452 t->data[i][ofs_mem + k] = 0;
453 }
454 }
455 else
456 {
457 for (k = 0; k < n; k++)
458 t->data[i][ofs_mem + k] = rawdata[ofs * t->row_count + i * n + k];
459 }
460 ofs_mem += m;
461 ofs += n;
462 }
463 }
464
465 free( rawdata );
466 return ERROR_SUCCESS;
467 err:
468 free( rawdata );
469 return ERROR_FUNCTION_FAILED;
470 }
471
472 void free_cached_tables( MSIDATABASE *db )
473 {
474 while( !list_empty( &db->tables ) )
475 {
476 MSITABLE *t = LIST_ENTRY( list_head( &db->tables ), MSITABLE, entry );
477
478 list_remove( &t->entry );
479 free_table( t );
480 }
481 }
482
483 static MSITABLE *find_cached_table( MSIDATABASE *db, LPCWSTR name )
484 {
485 MSITABLE *t;
486
487 LIST_FOR_EACH_ENTRY( t, &db->tables, MSITABLE, entry )
488 if( !wcscmp( name, t->name ) )
489 return t;
490
491 return NULL;
492 }
493
494 static void table_calc_column_offsets( MSIDATABASE *db, struct column_info *colinfo, DWORD count )
495 {
496 DWORD i;
497
498 for (i = 0; colinfo && i < count; i++)
499 {
500 assert( i + 1 == colinfo[i].number );
501 if (i) colinfo[i].offset = colinfo[i - 1].offset +
502 bytes_per_column( db, &colinfo[i - 1], LONG_STR_BYTES );
503 else colinfo[i].offset = 0;
504
505 TRACE("column %d is [%s] with type %08x ofs %d\n",
506 colinfo[i].number, debugstr_w(colinfo[i].colname),
507 colinfo[i].type, colinfo[i].offset);
508 }
509 }
510
511 static UINT get_defaulttablecolumns( MSIDATABASE *db, const WCHAR *name, struct column_info *colinfo, UINT *sz )
512 {
513 const struct column_info *p;
514 DWORD i, n;
515
516 TRACE("%s\n", debugstr_w(name));
517
518 if (!wcscmp( name, L"_Tables" ))
519 {
520 p = _Tables_cols;
521 n = 1;
522 }
523 else if (!wcscmp( name, L"_Columns" ))
524 {
525 p = _Columns_cols;
526 n = 4;
527 }
528 else return ERROR_FUNCTION_FAILED;
529
530 for (i = 0; i < n; i++)
531 {
532 if (colinfo && i < *sz) colinfo[i] = p[i];
533 if (colinfo && i >= *sz) break;
534 }
535 table_calc_column_offsets( db, colinfo, n );
536 *sz = n;
537 return ERROR_SUCCESS;
538 }
539
540 static UINT get_tablecolumns( MSIDATABASE *, const WCHAR *, struct column_info *, UINT * );
541
542 static UINT table_get_column_info( MSIDATABASE *db, const WCHAR *name, struct column_info **pcols, UINT *pcount )
543 {
544 UINT r, column_count = 0;
545 struct column_info *columns;
546
547 /* get the number of columns in this table */
548 column_count = 0;
549 r = get_tablecolumns( db, name, NULL, &column_count );
550 if (r != ERROR_SUCCESS)
551 return r;
552
553 *pcount = column_count;
554
555 /* if there are no columns, there's no table */
556 if (!column_count)
557 return ERROR_INVALID_PARAMETER;
558
559 TRACE("table %s found\n", debugstr_w(name));
560
561 columns = malloc( column_count * sizeof(*columns) );
562 if (!columns)
563 return ERROR_FUNCTION_FAILED;
564
565 r = get_tablecolumns( db, name, columns, &column_count );
566 if (r != ERROR_SUCCESS)
567 {
568 free( columns );
569 return ERROR_FUNCTION_FAILED;
570 }
571 *pcols = columns;
572 return r;
573 }
574
575 static UINT get_table( MSIDATABASE *db, LPCWSTR name, MSITABLE **table_ret )
576 {
577 MSITABLE *table;
578 UINT r;
579
580 /* first, see if the table is cached */
581 table = find_cached_table( db, name );
582 if (table)
583 {
584 *table_ret = table;
585 return ERROR_SUCCESS;
586 }
587
588 /* nonexistent tables should be interpreted as empty tables */
589 table = malloc( sizeof(MSITABLE) + wcslen( name ) * sizeof(WCHAR) );
590 if (!table)
591 return ERROR_FUNCTION_FAILED;
592
593 table->row_count = 0;
594 table->data = NULL;
595 table->data_persistent = NULL;
596 table->colinfo = NULL;
597 table->col_count = 0;
598 table->persistent = MSICONDITION_TRUE;
599 lstrcpyW( table->name, name );
600
601 if (!wcscmp( name, L"_Tables" ) || !wcscmp( name, L"_Columns" ))
602 table->persistent = MSICONDITION_NONE;
603
604 r = table_get_column_info( db, name, &table->colinfo, &table->col_count );
605 if (r != ERROR_SUCCESS)
606 {
607 free_table( table );
608 return r;
609 }
610 r = read_table_from_storage( db, table, db->storage );
611 if (r != ERROR_SUCCESS)
612 {
613 free_table( table );
614 return r;
615 }
616 list_add_head( &db->tables, &table->entry );
617 *table_ret = table;
618 return ERROR_SUCCESS;
619 }
620
621 static UINT read_table_int( BYTE *const *data, UINT row, UINT col, UINT bytes )
622 {
623 UINT ret = 0, i;
624
625 for (i = 0; i < bytes; i++)
626 ret += data[row][col + i] << i * 8;
627
628 return ret;
629 }
630
631 static UINT get_tablecolumns( MSIDATABASE *db, const WCHAR *szTableName, struct column_info *colinfo, UINT *sz )
632 {
633 UINT r, i, n = 0, table_id, count, maxcount = *sz;
634 MSITABLE *table = NULL;
635
636 TRACE("%s\n", debugstr_w(szTableName));
637
638 /* first check if there is a default table with that name */
639 r = get_defaulttablecolumns( db, szTableName, colinfo, sz );
640 if (r == ERROR_SUCCESS && *sz)
641 return r;
642
643 r = get_table( db, L"_Columns", &table );
644 if (r != ERROR_SUCCESS)
645 {
646 ERR("couldn't load _Columns table\n");
647 return ERROR_FUNCTION_FAILED;
648 }
649
650 /* convert table and column names to IDs from the string table */
651 r = msi_string2id( db->strings, szTableName, -1, &table_id );
652 if (r != ERROR_SUCCESS)
653 {
654 WARN("Couldn't find id for %s\n", debugstr_w(szTableName));
655 return r;
656 }
657 TRACE("Table id is %d, row count is %d\n", table_id, table->row_count);
658
659 /* Note: _Columns table doesn't have non-persistent data */
660
661 /* if maxcount is non-zero, assume it's exactly right for this table */
662 if (colinfo) memset( colinfo, 0, maxcount * sizeof(*colinfo) );
663 count = table->row_count;
664 for (i = 0; i < count; i++)
665 {
666 if (read_table_int( table->data, i, 0, LONG_STR_BYTES) != table_id) continue;
667 if (colinfo)
668 {
669 UINT id = read_table_int( table->data, i, table->colinfo[2].offset, LONG_STR_BYTES );
670 UINT col = read_table_int( table->data, i, table->colinfo[1].offset, sizeof(USHORT) ) - (1 << 15);
671
672 /* check the column number is in range */
673 if (col < 1 || col > maxcount)
674 {
675 ERR("column %d out of range (maxcount: %d)\n", col, maxcount);
676 continue;
677 }
678 /* check if this column was already set */
679 if (colinfo[col - 1].number)
680 {
681 ERR("duplicate column %d\n", col);
682 continue;
683 }
684 colinfo[col - 1].tablename = msi_string_lookup( db->strings, table_id, NULL );
685 colinfo[col - 1].number = col;
686 colinfo[col - 1].colname = msi_string_lookup( db->strings, id, NULL );
687 colinfo[col - 1].type = read_table_int( table->data, i, table->colinfo[3].offset,
688 sizeof(USHORT) ) - (1 << 15);
689 colinfo[col - 1].offset = 0;
690 colinfo[col - 1].hash_table = NULL;
691 }
692 n++;
693 }
694 TRACE("%s has %d columns\n", debugstr_w(szTableName), n);
695
696 if (colinfo && n != maxcount)
697 {
698 ERR("missing column in table %s\n", debugstr_w(szTableName));
699 free_colinfo( colinfo, maxcount );
700 return ERROR_FUNCTION_FAILED;
701 }
702 table_calc_column_offsets( db, colinfo, n );
703 *sz = n;
704 return ERROR_SUCCESS;
705 }
706
707 UINT msi_create_table( MSIDATABASE *db, LPCWSTR name, column_info *col_info,
708 MSICONDITION persistent, BOOL hold )
709 {
710 UINT r, nField;
711 MSIVIEW *tv = NULL;
712 MSIRECORD *rec = NULL;
713 column_info *col;
714 MSITABLE *table;
715 UINT i;
716
717 /* only add tables that don't exist already */
718 if( TABLE_Exists(db, name ) )
719 {
720 WARN("table %s exists\n", debugstr_w(name));
721 return ERROR_BAD_QUERY_SYNTAX;
722 }
723
724 table = malloc( sizeof(MSITABLE) + wcslen(name) * sizeof(WCHAR) );
725 if( !table )
726 return ERROR_FUNCTION_FAILED;
727
728 table->ref_count = 0;
729 table->row_count = 0;
730 table->data = NULL;
731 table->data_persistent = NULL;
732 table->colinfo = NULL;
733 table->col_count = 0;
734 table->persistent = persistent;
735 lstrcpyW( table->name, name );
736
737 if( hold )
738 table->ref_count++;
739
740 for( col = col_info; col; col = col->next )
741 table->col_count++;
742
743 table->colinfo = malloc( table->col_count * sizeof(*table->colinfo) );
744 if (!table->colinfo)
745 {
746 free_table( table );
747 return ERROR_FUNCTION_FAILED;
748 }
749
750 for( i = 0, col = col_info; col; i++, col = col->next )
751 {
752 UINT table_id = msi_add_string( db->strings, col->table, -1, persistent );
753 UINT col_id = msi_add_string( db->strings, col->column, -1, persistent );
754
755 table->colinfo[ i ].tablename = msi_string_lookup( db->strings, table_id, NULL );
756 table->colinfo[ i ].number = i + 1;
757 table->colinfo[ i ].colname = msi_string_lookup( db->strings, col_id, NULL );
758 table->colinfo[ i ].type = col->type;
759 table->colinfo[ i ].offset = 0;
760 table->colinfo[ i ].hash_table = NULL;
761 }
762 table_calc_column_offsets( db, table->colinfo, table->col_count);
763
764 r = TABLE_CreateView( db, L"_Tables", &tv );
765 TRACE("CreateView returned %x\n", r);
766 if( r )
767 {
768 free_table( table );
769 return r;
770 }
771
772 r = tv->ops->execute( tv, 0 );
773 TRACE("tv execute returned %x\n", r);
774 if( r )
775 goto err;
776
777 rec = MSI_CreateRecord( 1 );
778 if( !rec )
779 goto err;
780
781 r = MSI_RecordSetStringW( rec, 1, name );
782 if( r )
783 goto err;
784
785 r = tv->ops->insert_row( tv, rec, -1, persistent == MSICONDITION_FALSE );
786 TRACE("insert_row returned %x\n", r);
787 if( r )
788 goto err;
789
790 tv->ops->delete( tv );
791 tv = NULL;
792
793 msiobj_release( &rec->hdr );
794 rec = NULL;
795
796 if( persistent != MSICONDITION_FALSE )
797 {
798 /* add each column to the _Columns table */
799 r = TABLE_CreateView( db, L"_Columns", &tv );
800 if( r )
801 goto err;
802
803 r = tv->ops->execute( tv, 0 );
804 TRACE("tv execute returned %x\n", r);
805 if( r )
806 goto err;
807
808 rec = MSI_CreateRecord( 4 );
809 if( !rec )
810 goto err;
811
812 r = MSI_RecordSetStringW( rec, 1, name );
813 if( r )
814 goto err;
815
816 /*
817 * need to set the table, column number, col name and type
818 * for each column we enter in the table
819 */
820 nField = 1;
821 for( col = col_info; col; col = col->next )
822 {
823 r = MSI_RecordSetInteger( rec, 2, nField );
824 if( r )
825 goto err;
826
827 r = MSI_RecordSetStringW( rec, 3, col->column );
828 if( r )
829 goto err;
830
831 r = MSI_RecordSetInteger( rec, 4, col->type );
832 if( r )
833 goto err;
834
835 r = tv->ops->insert_row( tv, rec, -1, FALSE );
836 if( r )
837 goto err;
838
839 nField++;
840 }
841 if( !col )
842 r = ERROR_SUCCESS;
843 }
844
845 err:
846 if (rec)
847 msiobj_release( &rec->hdr );
848 /* FIXME: remove values from the string table on error */
849 if( tv )
850 tv->ops->delete( tv );
851
852 if (r == ERROR_SUCCESS)
853 list_add_head( &db->tables, &table->entry );
854 else
855 free_table( table );
856
857 return r;
858 }
859
860 static UINT save_table( MSIDATABASE *db, const MSITABLE *t, UINT bytes_per_strref )
861 {
862 BYTE *rawdata = NULL;
863 UINT rawsize, i, j, row_size, row_count;
864 UINT r = ERROR_FUNCTION_FAILED;
865
866 /* Nothing to do for non-persistent tables */
867 if( t->persistent == MSICONDITION_FALSE )
868 return ERROR_SUCCESS;
869
870 TRACE("Saving %s\n", debugstr_w( t->name ) );
871
872 row_size = table_get_row_size( db, t->colinfo, t->col_count, bytes_per_strref );
873 row_count = t->row_count;
874 for (i = 0; i < t->row_count; i++)
875 {
876 if (!t->data_persistent[i])
877 {
878 row_count = 1; /* yes, this is bizarre */
879 break;
880 }
881 }
882 rawsize = row_count * row_size;
883 rawdata = calloc( 1, rawsize );
884 if( !rawdata )
885 {
886 r = ERROR_NOT_ENOUGH_MEMORY;
887 goto err;
888 }
889
890 rawsize = 0;
891 for (i = 0; i < row_count; i++)
892 {
893 UINT ofs = 0, ofs_mem = 0;
894
895 if (!t->data_persistent[i]) break;
896
897 for (j = 0; j < t->col_count; j++)
898 {
899 UINT m = bytes_per_column( db, &t->colinfo[j], LONG_STR_BYTES );
900 UINT n = bytes_per_column( db, &t->colinfo[j], bytes_per_strref );
901 UINT k;
902
903 if (n != 2 && n != 3 && n != 4)
904 {
905 ERR("oops - unknown column width %d\n", n);
906 goto err;
907 }
908 if (t->colinfo[j].type & MSITYPE_STRING && n < m)
909 {
910 UINT id = read_table_int( t->data, i, ofs_mem, LONG_STR_BYTES );
911 if (id > 1 << bytes_per_strref * 8)
912 {
913 ERR("string id %u out of range\n", id);
914 goto err;
915 }
916 }
917 for (k = 0; k < n; k++)
918 {
919 rawdata[ofs * row_count + i * n + k] = t->data[i][ofs_mem + k];
920 }
921 ofs_mem += m;
922 ofs += n;
923 }
924 rawsize += row_size;
925 }
926
927 TRACE("writing %d bytes\n", rawsize);
928 r = write_stream_data( db->storage, t->name, rawdata, rawsize, TRUE );
929
930 err:
931 free( rawdata );
932 return r;
933 }
934
935 static void update_table_columns( MSIDATABASE *db, const WCHAR *name )
936 {
937 MSITABLE *table;
938 UINT size, offset, old_count;
939 UINT n;
940
941 if (!(table = find_cached_table( db, name ))) return;
942 old_count = table->col_count;
943 free_colinfo( table->colinfo, table->col_count );
944 free( table->colinfo );
945 table->colinfo = NULL;
946
947 table_get_column_info( db, name, &table->colinfo, &table->col_count );
948 if (!table->col_count) return;
949
950 size = table_get_row_size( db, table->colinfo, table->col_count, LONG_STR_BYTES );
951 offset = table->colinfo[table->col_count - 1].offset;
952
953 for ( n = 0; n < table->row_count; n++ )
954 {
955 table->data[n] = realloc( table->data[n], size );
956 if (old_count < table->col_count)
957 memset( &table->data[n][offset], 0, size - offset );
958 }
959 }
960
961 /* try to find the table name in the _Tables table */
962 BOOL TABLE_Exists( MSIDATABASE *db, LPCWSTR name )
963 {
964 UINT r, table_id, i;
965 MSITABLE *table;
966
967 if( !wcscmp( name, L"_Tables" ) || !wcscmp( name, L"_Columns" ) ||
968 !wcscmp( name, L"_Streams" ) || !wcscmp( name, L"_Storages" ) )
969 return TRUE;
970
971 r = msi_string2id( db->strings, name, -1, &table_id );
972 if( r != ERROR_SUCCESS )
973 {
974 TRACE("Couldn't find id for %s\n", debugstr_w(name));
975 return FALSE;
976 }
977
978 r = get_table( db, L"_Tables", &table );
979 if( r != ERROR_SUCCESS )
980 {
981 ERR("table _Tables not available\n");
982 return FALSE;
983 }
984
985 for( i = 0; i < table->row_count; i++ )
986 {
987 if( read_table_int( table->data, i, 0, LONG_STR_BYTES ) == table_id )
988 return TRUE;
989 }
990
991 return FALSE;
992 }
993
994 /* below is the query interface to a table */
995
996 struct table_view
997 {
998 MSIVIEW view;
999 MSIDATABASE *db;
1000 MSITABLE *table;
1001 struct column_info *columns;
1002 UINT num_cols;
1003 UINT row_size;
1004 WCHAR name[1];
1005 };
1006
1007 static UINT TABLE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
1008 {
1009 struct table_view *tv = (struct table_view *)view;
1010 UINT offset, n;
1011
1012 if( !tv->table )
1013 return ERROR_INVALID_PARAMETER;
1014
1015 if( (col==0) || (col>tv->num_cols) )
1016 return ERROR_INVALID_PARAMETER;
1017
1018 /* how many rows are there ? */
1019 if( row >= tv->table->row_count )
1020 return ERROR_NO_MORE_ITEMS;
1021
1022 if( tv->columns[col-1].offset >= tv->row_size )
1023 {
1024 ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1025 ERR("%p %p\n", tv, tv->columns );
1026 return ERROR_FUNCTION_FAILED;
1027 }
1028
1029 n = bytes_per_column( tv->db, &tv->columns[col - 1], LONG_STR_BYTES );
1030 if (n != 2 && n != 3 && n != 4)
1031 {
1032 ERR("oops! what is %d bytes per column?\n", n );
1033 return ERROR_FUNCTION_FAILED;
1034 }
1035
1036 offset = tv->columns[col-1].offset;
1037 *val = read_table_int(tv->table->data, row, offset, n);
1038
1039 /* TRACE("Data [%d][%d] = %d\n", row, col, *val ); */
1040
1041 return ERROR_SUCCESS;
1042 }
1043
1044 static UINT get_stream_name( const struct table_view *tv, UINT row, WCHAR **pstname )
1045 {
1046 LPWSTR p, stname = NULL;
1047 UINT i, r, type, ival;
1048 DWORD len;
1049 LPCWSTR sval;
1050 MSIVIEW *view = (MSIVIEW *) tv;
1051
1052 TRACE("%p %d\n", tv, row);
1053
1054 len = lstrlenW( tv->name ) + 1;
1055 stname = malloc( len * sizeof(WCHAR) );
1056 if ( !stname )
1057 {
1058 r = ERROR_OUTOFMEMORY;
1059 goto err;
1060 }
1061
1062 lstrcpyW( stname, tv->name );
1063
1064 for ( i = 0; i < tv->num_cols; i++ )
1065 {
1066 type = tv->columns[i].type;
1067 if ( type & MSITYPE_KEY )
1068 {
1069 WCHAR number[0x20];
1070
1071 r = TABLE_fetch_int( view, row, i+1, &ival );
1072 if ( r != ERROR_SUCCESS )
1073 goto err;
1074
1075 if ( tv->columns[i].type & MSITYPE_STRING )
1076 {
1077 sval = msi_string_lookup( tv->db->strings, ival, NULL );
1078 if ( !sval )
1079 {
1080 r = ERROR_INVALID_PARAMETER;
1081 goto err;
1082 }
1083 }
1084 else
1085 {
1086 UINT n = bytes_per_column( tv->db, &tv->columns[i], LONG_STR_BYTES );
1087
1088 switch( n )
1089 {
1090 case 2:
1091 swprintf( number, ARRAY_SIZE(number), L"%d", ival-0x8000 );
1092 break;
1093 case 4:
1094 swprintf( number, ARRAY_SIZE(number), L"%d", ival^0x80000000 );
1095 break;
1096 default:
1097 ERR( "oops - unknown column width %d\n", n );
1098 r = ERROR_FUNCTION_FAILED;
1099 goto err;
1100 }
1101 sval = number;
1102 }
1103
1104 len += lstrlenW( L"." ) + lstrlenW( sval );
1105 p = realloc( stname, len * sizeof(WCHAR) );
1106 if ( !p )
1107 {
1108 r = ERROR_OUTOFMEMORY;
1109 goto err;
1110 }
1111 stname = p;
1112
1113 lstrcatW( stname, L"." );
1114 lstrcatW( stname, sval );
1115 }
1116 else
1117 continue;
1118 }
1119
1120 *pstname = stname;
1121 return ERROR_SUCCESS;
1122
1123 err:
1124 free( stname );
1125 *pstname = NULL;
1126 return r;
1127 }
1128
1129 /*
1130 * We need a special case for streams, as we need to reference column with
1131 * the name of the stream in the same table, and the table name
1132 * which may not be available at higher levels of the query
1133 */
1134 static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
1135 {
1136 struct table_view *tv = (struct table_view *)view;
1137 UINT r;
1138 WCHAR *name;
1139
1140 if( !view->ops->fetch_int )
1141 return ERROR_INVALID_PARAMETER;
1142
1143 r = get_stream_name( tv, row, &name );
1144 if (r != ERROR_SUCCESS)
1145 {
1146 ERR("fetching stream, error = %u\n", r);
1147 return r;
1148 }
1149
1150 r = msi_get_stream( tv->db, name, stm );
1151 if (r != ERROR_SUCCESS)
1152 ERR("fetching stream %s, error = %u\n", debugstr_w(name), r);
1153
1154 free( name );
1155 return r;
1156 }
1157
1158 /* Set a table value, i.e. preadjusted integer or string ID. */
1159 static UINT table_set_bytes( struct table_view *tv, UINT row, UINT col, UINT val )
1160 {
1161 UINT offset, n, i;
1162
1163 if( !tv->table )
1164 return ERROR_INVALID_PARAMETER;
1165
1166 if( (col==0) || (col>tv->num_cols) )
1167 return ERROR_INVALID_PARAMETER;
1168
1169 if( row >= tv->table->row_count )
1170 return ERROR_INVALID_PARAMETER;
1171
1172 if( tv->columns[col-1].offset >= tv->row_size )
1173 {
1174 ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1175 ERR("%p %p\n", tv, tv->columns );
1176 return ERROR_FUNCTION_FAILED;
1177 }
1178
1179 free( tv->columns[col-1].hash_table );
1180 tv->columns[col-1].hash_table = NULL;
1181
1182 n = bytes_per_column( tv->db, &tv->columns[col - 1], LONG_STR_BYTES );
1183 if ( n != 2 && n != 3 && n != 4 )
1184 {
1185 ERR("oops! what is %d bytes per column?\n", n );
1186 return ERROR_FUNCTION_FAILED;
1187 }
1188
1189 offset = tv->columns[col-1].offset;
1190 for ( i = 0; i < n; i++ )
1191 tv->table->data[row][offset + i] = (val >> i * 8) & 0xff;
1192
1193 return ERROR_SUCCESS;
1194 }
1195
1196 static UINT int_to_table_storage( const struct table_view *tv, UINT col, int val, UINT *ret )
1197 {
1198 if ((tv->columns[col-1].type & MSI_DATASIZEMASK) == 2)
1199 {
1200 if (val == MSI_NULL_INTEGER)
1201 *ret = 0;
1202 else if ((val + 0x8000) & 0xffff0000)
1203 {
1204 ERR("value %d out of range\n", val);
1205 return ERROR_FUNCTION_FAILED;
1206 }
1207 else
1208 *ret = val + 0x8000;
1209 }
1210 else
1211 *ret = val ^ 0x80000000;
1212
1213 return ERROR_SUCCESS;
1214 }
1215
1216 static UINT TABLE_set_int( MSIVIEW *view, UINT row, UINT col, int val )
1217 {
1218 struct table_view *tv = (struct table_view *)view;
1219 UINT r, table_int;
1220
1221 TRACE("row %u, col %u, val %d.\n", row, col, val);
1222
1223 if ((r = int_to_table_storage( tv, col, val, &table_int )))
1224 return r;
1225
1226 if (tv->columns[col-1].type & MSITYPE_KEY)
1227 {
1228 UINT key;
1229
1230 if ((r = TABLE_fetch_int( view, row, col, &key )))
1231 return r;
1232 if (key != table_int)
1233 {
1234 ERR("Cannot modify primary key %s.%s.\n",
1235 debugstr_w(tv->table->name), debugstr_w(tv->columns[col-1].colname));
1236 return ERROR_FUNCTION_FAILED;
1237 }
1238 }
1239
1240 return table_set_bytes( tv, row, col, table_int );
1241 }
1242
1243 static UINT TABLE_set_string( MSIVIEW *view, UINT row, UINT col, const WCHAR *val, int len )
1244 {
1245 struct table_view *tv = (struct table_view *)view;
1246 BOOL persistent;
1247 UINT id, r;
1248
1249 TRACE("row %u, col %u, val %s.\n", row, col, debugstr_wn(val, len));
1250
1251 persistent = (tv->table->persistent != MSICONDITION_FALSE)
1252 && tv->table->data_persistent[row];
1253
1254 if (val)
1255 {
1256 r = msi_string2id( tv->db->strings, val, len, &id );
1257 if (r != ERROR_SUCCESS)
1258 id = msi_add_string( tv->db->strings, val, len, persistent );
1259 }
1260 else
1261 id = 0;
1262
1263 if (tv->columns[col-1].type & MSITYPE_KEY)
1264 {
1265 UINT key;
1266
1267 if ((r = TABLE_fetch_int( view, row, col, &key )))
1268 return r;
1269 if (key != id)
1270 {
1271 ERR("Cannot modify primary key %s.%s.\n",
1272 debugstr_w(tv->table->name), debugstr_w(tv->columns[col-1].colname));
1273 return ERROR_FUNCTION_FAILED;
1274 }
1275 }
1276
1277 return table_set_bytes( tv, row, col, id );
1278 }
1279
1280 static UINT TABLE_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec )
1281 {
1282 struct table_view *tv = (struct table_view *)view;
1283
1284 if (!tv->table)
1285 return ERROR_INVALID_PARAMETER;
1286
1287 return msi_view_get_row(tv->db, view, row, rec);
1288 }
1289
1290 static UINT add_stream( MSIDATABASE *db, const WCHAR *name, IStream *data )
1291 {
1292 MSIQUERY *query;
1293 MSIRECORD *rec;
1294 UINT r;
1295
1296 TRACE("%p %s %p\n", db, debugstr_w(name), data);
1297
1298 if (!(rec = MSI_CreateRecord( 2 )))
1299 return ERROR_OUTOFMEMORY;
1300
1301 r = MSI_RecordSetStringW( rec, 1, name );
1302 if (r != ERROR_SUCCESS)
1303 goto done;
1304
1305 r = MSI_RecordSetIStream( rec, 2, data );
1306 if (r != ERROR_SUCCESS)
1307 goto done;
1308
1309 r = MSI_DatabaseOpenViewW( db, L"INSERT INTO `_Streams` (`Name`,`Data`) VALUES (?,?)", &query );
1310 if (r != ERROR_SUCCESS)
1311 goto done;
1312
1313 r = MSI_ViewExecute( query, rec );
1314 msiobj_release( &query->hdr );
1315 if (r == ERROR_SUCCESS)
1316 goto done;
1317
1318 msiobj_release( &rec->hdr );
1319 if (!(rec = MSI_CreateRecord( 2 )))
1320 return ERROR_OUTOFMEMORY;
1321
1322 r = MSI_RecordSetIStream( rec, 1, data );
1323 if (r != ERROR_SUCCESS)
1324 goto done;
1325
1326 r = MSI_RecordSetStringW( rec, 2, name );
1327 if (r != ERROR_SUCCESS)
1328 goto done;
1329
1330 r = MSI_DatabaseOpenViewW( db, L"UPDATE `_Streams` SET `Data` = ? WHERE `Name` = ?", &query );
1331 if (r != ERROR_SUCCESS)
1332 goto done;
1333
1334 r = MSI_ViewExecute( query, rec );
1335 msiobj_release( &query->hdr );
1336
1337 done:
1338 msiobj_release( &rec->hdr );
1339 return r;
1340 }
1341
1342 static UINT TABLE_set_stream( MSIVIEW *view, UINT row, UINT col, IStream *stream )
1343 {
1344 struct table_view *tv = (struct table_view *)view;
1345 WCHAR *name;
1346 UINT r;
1347
1348 TRACE("row %u, col %u, stream %p.\n", row, col, stream);
1349
1350 if ((r = get_stream_name( tv, row - 1, &name )))
1351 return r;
1352
1353 r = add_stream( tv->db, name, stream );
1354 free( name );
1355 return r;
1356 }
1357
1358 static UINT get_table_value_from_record( struct table_view *tv, MSIRECORD *rec, UINT iField, UINT *pvalue )
1359 {
1360 struct column_info columninfo;
1361 UINT r;
1362
1363 if (!iField || iField > tv->num_cols || MSI_RecordIsNull( rec, iField ))
1364 return ERROR_FUNCTION_FAILED;
1365
1366 columninfo = tv->columns[ iField - 1 ];
1367
1368 if ( MSITYPE_IS_BINARY(columninfo.type) )
1369 {
1370 *pvalue = 1; /* refers to the first key column */
1371 }
1372 else if ( columninfo.type & MSITYPE_STRING )
1373 {
1374 int len;
1375 const WCHAR *sval = msi_record_get_string( rec, iField, &len );
1376 if (sval)
1377 {
1378 r = msi_string2id( tv->db->strings, sval, len, pvalue );
1379 if (r != ERROR_SUCCESS)
1380 return ERROR_NOT_FOUND;
1381 }
1382 else *pvalue = 0;
1383 }
1384 else
1385 return int_to_table_storage( tv, iField, MSI_RecordGetInteger( rec, iField ), pvalue );
1386
1387 return ERROR_SUCCESS;
1388 }
1389
1390 static UINT TABLE_set_row( struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask )
1391 {
1392 struct table_view *tv = (struct table_view *)view;
1393 UINT i, val, r = ERROR_SUCCESS;
1394
1395 if ( !tv->table )
1396 return ERROR_INVALID_PARAMETER;
1397
1398 /* test if any of the mask bits are invalid */
1399 if ( mask >= (1<<tv->num_cols) )
1400 return ERROR_INVALID_PARAMETER;
1401
1402 for ( i = 0; i < tv->num_cols; i++ )
1403 {
1404 BOOL persistent;
1405
1406 /* only update the fields specified in the mask */
1407 if ( !(mask&(1<<i)) )
1408 continue;
1409
1410 persistent = (tv->table->persistent != MSICONDITION_FALSE) &&
1411 (tv->table->data_persistent[row]);
1412 /* FIXME: should we allow updating keys? */
1413
1414 val = 0;
1415 if ( !MSI_RecordIsNull( rec, i + 1 ) )
1416 {
1417 r = get_table_value_from_record (tv, rec, i + 1, &val);
1418 if ( MSITYPE_IS_BINARY(tv->columns[ i ].type) )
1419 {
1420 IStream *stm;
1421 LPWSTR stname;
1422
1423 if ( r != ERROR_SUCCESS )
1424 return ERROR_FUNCTION_FAILED;
1425
1426 r = MSI_RecordGetIStream( rec, i + 1, &stm );
1427 if ( r != ERROR_SUCCESS )
1428 return r;
1429
1430 r = get_stream_name( tv, row, &stname );
1431 if ( r != ERROR_SUCCESS )
1432 {
1433 IStream_Release( stm );
1434 return r;
1435 }
1436
1437 r = add_stream( tv->db, stname, stm );
1438 IStream_Release( stm );
1439 free( stname );
1440
1441 if ( r != ERROR_SUCCESS )
1442 return r;
1443 }
1444 else if ( tv->columns[i].type & MSITYPE_STRING )
1445 {
1446 UINT x;
1447
1448 if ( r != ERROR_SUCCESS )
1449 {
1450 int len;
1451 const WCHAR *sval = msi_record_get_string( rec, i + 1, &len );
1452 val = msi_add_string( tv->db->strings, sval, len, persistent );
1453 }
1454 else
1455 {
1456 TABLE_fetch_int(&tv->view, row, i + 1, &x);
1457 if (val == x)
1458 continue;
1459 }
1460 }
1461 else
1462 {
1463 if ( r != ERROR_SUCCESS )
1464 return ERROR_FUNCTION_FAILED;
1465 }
1466 }
1467
1468 r = table_set_bytes( tv, row, i+1, val );
1469 if ( r != ERROR_SUCCESS )
1470 break;
1471 }
1472 return r;
1473 }
1474
1475 static UINT table_create_new_row( struct tagMSIVIEW *view, UINT *num, BOOL temporary )
1476 {
1477 struct table_view *tv = (struct table_view *)view;
1478 BYTE **p, *row;
1479 BOOL *b;
1480 UINT sz;
1481 BYTE ***data_ptr;
1482 BOOL **data_persist_ptr;
1483 UINT *row_count;
1484
1485 TRACE("%p %s\n", view, temporary ? "TRUE" : "FALSE");
1486
1487 if( !tv->table )
1488 return ERROR_INVALID_PARAMETER;
1489
1490 row = calloc( 1, tv->row_size );
1491 if( !row )
1492 return ERROR_NOT_ENOUGH_MEMORY;
1493
1494 row_count = &tv->table->row_count;
1495 data_ptr = &tv->table->data;
1496 data_persist_ptr = &tv->table->data_persistent;
1497 if (*num == -1)
1498 *num = tv->table->row_count;
1499
1500 sz = (*row_count + 1) * sizeof (BYTE*);
1501 if( *data_ptr )
1502 p = realloc( *data_ptr, sz );
1503 else
1504 p = malloc( sz );
1505 if( !p )
1506 {
1507 free( row );
1508 return ERROR_NOT_ENOUGH_MEMORY;
1509 }
1510
1511 sz = (*row_count + 1) * sizeof (BOOL);
1512 if( *data_persist_ptr )
1513 b = realloc( *data_persist_ptr, sz );
1514 else
1515 b = malloc( sz );
1516 if( !b )
1517 {
1518 free( row );
1519 free( p );
1520 return ERROR_NOT_ENOUGH_MEMORY;
1521 }
1522
1523 *data_ptr = p;
1524 (*data_ptr)[*row_count] = row;
1525
1526 *data_persist_ptr = b;
1527 (*data_persist_ptr)[*row_count] = !temporary;
1528
1529 (*row_count)++;
1530
1531 return ERROR_SUCCESS;
1532 }
1533
1534 static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
1535 {
1536 struct table_view *tv = (struct table_view *)view;
1537
1538 TRACE("%p %p\n", tv, record);
1539
1540 TRACE("There are %d columns\n", tv->num_cols );
1541
1542 return ERROR_SUCCESS;
1543 }
1544
1545 static UINT TABLE_close( struct tagMSIVIEW *view )
1546 {
1547 TRACE("%p\n", view );
1548
1549 return ERROR_SUCCESS;
1550 }
1551
1552 static UINT TABLE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols)
1553 {
1554 struct table_view *tv = (struct table_view *)view;
1555
1556 TRACE("%p %p %p\n", view, rows, cols );
1557
1558 if( cols )
1559 *cols = tv->num_cols;
1560 if( rows )
1561 {
1562 if( !tv->table )
1563 return ERROR_INVALID_PARAMETER;
1564 *rows = tv->table->row_count;
1565 }
1566
1567 return ERROR_SUCCESS;
1568 }
1569
1570 static UINT TABLE_get_column_info( struct tagMSIVIEW *view,
1571 UINT n, LPCWSTR *name, UINT *type, BOOL *temporary,
1572 LPCWSTR *table_name )
1573 {
1574 struct table_view *tv = (struct table_view *)view;
1575
1576 TRACE("%p %d %p %p\n", tv, n, name, type );
1577
1578 if( ( n == 0 ) || ( n > tv->num_cols ) )
1579 return ERROR_INVALID_PARAMETER;
1580
1581 if( name )
1582 {
1583 *name = tv->columns[n-1].colname;
1584 if( !*name )
1585 return ERROR_FUNCTION_FAILED;
1586 }
1587
1588 if( table_name )
1589 {
1590 *table_name = tv->columns[n-1].tablename;
1591 if( !*table_name )
1592 return ERROR_FUNCTION_FAILED;
1593 }
1594
1595 if( type )
1596 *type = tv->columns[n-1].type;
1597
1598 if( temporary )
1599 *temporary = (tv->columns[n-1].type & MSITYPE_TEMPORARY) != 0;
1600
1601 return ERROR_SUCCESS;
1602 }
1603
1604 static UINT table_find_row( struct table_view *, MSIRECORD *, UINT *, UINT * );
1605
1606 static UINT table_validate_new( struct table_view *tv, MSIRECORD *rec, UINT *column )
1607 {
1608 UINT r, row, i;
1609
1610 /* check there are no null values where they're not allowed */
1611 for( i = 0; i < tv->num_cols; i++ )
1612 {
1613 if ( tv->columns[i].type & MSITYPE_NULLABLE )
1614 continue;
1615
1616 if ( MSITYPE_IS_BINARY(tv->columns[i].type) )
1617 TRACE("skipping binary column\n");
1618 else if ( tv->columns[i].type & MSITYPE_STRING )
1619 {
1620 int len;
1621 const WCHAR *str = msi_record_get_string( rec, i+1, &len );
1622
1623 if (!str || (!str[0] && !len))
1624 {
1625 if (column) *column = i;
1626 return ERROR_INVALID_DATA;
1627 }
1628 }
1629 else
1630 {
1631 UINT n;
1632
1633 n = MSI_RecordGetInteger( rec, i+1 );
1634 if (n == MSI_NULL_INTEGER)
1635 {
1636 if (column) *column = i;
1637 return ERROR_INVALID_DATA;
1638 }
1639 }
1640 }
1641
1642 /* check there are no duplicate keys */
1643 r = table_find_row( tv, rec, &row, column );
1644 if (r == ERROR_SUCCESS)
1645 return ERROR_FUNCTION_FAILED;
1646
1647 return ERROR_SUCCESS;
1648 }
1649
1650 static int compare_record( struct table_view *tv, UINT row, MSIRECORD *rec )
1651 {
1652 UINT r, i, ivalue, x;
1653
1654 for (i = 0; i < tv->num_cols; i++ )
1655 {
1656 if (!(tv->columns[i].type & MSITYPE_KEY)) continue;
1657
1658 r = get_table_value_from_record( tv, rec, i + 1, &ivalue );
1659 if (r != ERROR_SUCCESS)
1660 return 1;
1661
1662 r = TABLE_fetch_int( &tv->view, row, i + 1, &x );
1663 if (r != ERROR_SUCCESS)
1664 {
1665 WARN("TABLE_fetch_int should not fail here %u\n", r);
1666 return -1;
1667 }
1668 if (ivalue > x)
1669 {
1670 return 1;
1671 }
1672 else if (ivalue == x)
1673 {
1674 if (i < tv->num_cols - 1) continue;
1675 return 0;
1676 }
1677 else
1678 return -1;
1679 }
1680 return 1;
1681 }
1682
1683 static int find_insert_index( struct table_view *tv, MSIRECORD *rec )
1684 {
1685 int idx, c, low = 0, high = tv->table->row_count - 1;
1686
1687 TRACE("%p %p\n", tv, rec);
1688
1689 while (low <= high)
1690 {
1691 idx = (low + high) / 2;
1692 c = compare_record( tv, idx, rec );
1693
1694 if (c < 0)
1695 high = idx - 1;
1696 else if (c > 0)
1697 low = idx + 1;
1698 else
1699 {
1700 TRACE("found %u\n", idx);
1701 return idx;
1702 }
1703 }
1704 TRACE("found %u\n", high + 1);
1705 return high + 1;
1706 }
1707
1708 static UINT TABLE_insert_row( struct tagMSIVIEW *view, MSIRECORD *rec, UINT row, BOOL temporary )
1709 {
1710 struct table_view *tv = (struct table_view *)view;
1711 UINT i, r;
1712
1713 TRACE("%p %p %s\n", tv, rec, temporary ? "TRUE" : "FALSE" );
1714
1715 /* check that the key is unique - can we find a matching row? */
1716 r = table_validate_new( tv, rec, NULL );
1717 if( r != ERROR_SUCCESS )
1718 return ERROR_FUNCTION_FAILED;
1719
1720 if (row == -1)
1721 row = find_insert_index( tv, rec );
1722
1723 r = table_create_new_row( view, &row, temporary );
1724 TRACE("insert_row returned %08x\n", r);
1725 if( r != ERROR_SUCCESS )
1726 return r;
1727
1728 /* shift the rows to make room for the new row */
1729 for (i = tv->table->row_count - 1; i > row; i--)
1730 {
1731 memmove(&(tv->table->data[i][0]),
1732 &(tv->table->data[i - 1][0]), tv->row_size);
1733 tv->table->data_persistent[i] = tv->table->data_persistent[i - 1];
1734 }
1735
1736 /* Re-set the persistence flag */
1737 tv->table->data_persistent[row] = !temporary;
1738 return TABLE_set_row( view, row, rec, (1<<tv->num_cols) - 1 );
1739 }
1740
1741 static UINT TABLE_delete_row( struct tagMSIVIEW *view, UINT row )
1742 {
1743 struct table_view *tv = (struct table_view *)view;
1744 UINT r, num_rows, num_cols, i;
1745
1746 TRACE("%p %d\n", tv, row);
1747
1748 if ( !tv->table )
1749 return ERROR_INVALID_PARAMETER;
1750
1751 r = TABLE_get_dimensions( view, &num_rows, &num_cols );
1752 if ( r != ERROR_SUCCESS )
1753 return r;
1754
1755 if ( row >= num_rows )
1756 return ERROR_FUNCTION_FAILED;
1757
1758 num_rows = tv->table->row_count;
1759 tv->table->row_count--;
1760
1761 /* reset the hash tables */
1762 for (i = 0; i < tv->num_cols; i++)
1763 {
1764 free(tv->columns[i].hash_table);
1765 tv->columns[i].hash_table = NULL;
1766 }
1767
1768 for (i = row + 1; i < num_rows; i++)
1769 {
1770 memcpy(tv->table->data[i - 1], tv->table->data[i], tv->row_size);
1771 tv->table->data_persistent[i - 1] = tv->table->data_persistent[i];
1772 }
1773
1774 free(tv->table->data[num_rows - 1]);
1775
1776 return ERROR_SUCCESS;
1777 }
1778
1779 static UINT table_update(struct tagMSIVIEW *view, MSIRECORD *rec, UINT row)
1780 {
1781 struct table_view *tv = (struct table_view *)view;
1782 UINT r, new_row;
1783
1784 /* FIXME: MsiViewFetch should set rec index 0 to some ID that
1785 * sets the fetched record apart from other records
1786 */
1787
1788 if (!tv->table)
1789 return ERROR_INVALID_PARAMETER;
1790
1791 r = table_find_row(tv, rec, &new_row, NULL);
1792 if (r != ERROR_SUCCESS)
1793 {
1794 ERR("can't find row to modify\n");
1795 return ERROR_FUNCTION_FAILED;
1796 }
1797
1798 /* the row cannot be changed */
1799 if (row != new_row)
1800 return ERROR_FUNCTION_FAILED;
1801
1802 return TABLE_set_row(view, new_row, rec, (1 << tv->num_cols) - 1);
1803 }
1804
1805 static UINT table_assign(struct tagMSIVIEW *view, MSIRECORD *rec)
1806 {
1807 struct table_view *tv = (struct table_view *)view;
1808 UINT r, row;
1809
1810 if (!tv->table)
1811 return ERROR_INVALID_PARAMETER;
1812
1813 r = table_find_row(tv, rec, &row, NULL);
1814 if (r == ERROR_SUCCESS)
1815 return TABLE_set_row(view, row, rec, (1 << tv->num_cols) - 1);
1816 else
1817 return TABLE_insert_row( view, rec, -1, FALSE );
1818 }
1819
1820 static UINT refresh_record( struct tagMSIVIEW *view, MSIRECORD *rec, UINT row )
1821 {
1822 MSIRECORD *curr;
1823 UINT r, i, count;
1824
1825 r = TABLE_get_row(view, row, &curr);
1826 if (r != ERROR_SUCCESS)
1827 return r;
1828
1829 /* Close the original record */
1830 MSI_CloseRecord(&rec->hdr);
1831
1832 count = MSI_RecordGetFieldCount(rec);
1833 for (i = 0; i < count; i++)
1834 MSI_RecordCopyField(curr, i + 1, rec, i + 1);
1835
1836 msiobj_release(&curr->hdr);
1837 return ERROR_SUCCESS;
1838 }
1839
1840 static UINT TABLE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
1841 MSIRECORD *rec, UINT row)
1842 {
1843 struct table_view *tv = (struct table_view *)view;
1844 UINT r, frow, column;
1845
1846 TRACE("%p %d %p\n", view, eModifyMode, rec );
1847
1848 switch (eModifyMode)
1849 {
1850 case MSIMODIFY_DELETE:
1851 r = TABLE_delete_row( view, row );
1852 break;
1853 case MSIMODIFY_VALIDATE_NEW:
1854 r = table_validate_new( tv, rec, &column );
1855 if (r != ERROR_SUCCESS)
1856 {
1857 tv->view.error = MSIDBERROR_DUPLICATEKEY;
1858 tv->view.error_column = tv->columns[column].colname;
1859 r = ERROR_INVALID_DATA;
1860 }
1861 break;
1862
1863 case MSIMODIFY_INSERT:
1864 r = table_validate_new( tv, rec, NULL );
1865 if (r != ERROR_SUCCESS)
1866 break;
1867 r = TABLE_insert_row( view, rec, -1, FALSE );
1868 break;
1869
1870 case MSIMODIFY_INSERT_TEMPORARY:
1871 r = table_validate_new( tv, rec, NULL );
1872 if (r != ERROR_SUCCESS)
1873 break;
1874 r = TABLE_insert_row( view, rec, -1, TRUE );
1875 break;
1876
1877 case MSIMODIFY_REFRESH:
1878 r = refresh_record( view, rec, row );
1879 break;
1880
1881 case MSIMODIFY_UPDATE:
1882 r = table_update( view, rec, row );
1883 break;
1884
1885 case MSIMODIFY_ASSIGN:
1886 r = table_assign( view, rec );
1887 break;
1888
1889 case MSIMODIFY_MERGE:
1890 /* check row that matches this record */
1891 r = table_find_row( tv, rec, &frow, &column );
1892 if (r != ERROR_SUCCESS)
1893 {
1894 r = table_validate_new( tv, rec, NULL );
1895 if (r == ERROR_SUCCESS)
1896 r = TABLE_insert_row( view, rec, -1, FALSE );
1897 }
1898 break;
1899
1900 case MSIMODIFY_REPLACE:
1901 case MSIMODIFY_VALIDATE:
1902 case MSIMODIFY_VALIDATE_FIELD:
1903 case MSIMODIFY_VALIDATE_DELETE:
1904 FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
1905 r = ERROR_CALL_NOT_IMPLEMENTED;
1906 break;
1907
1908 default:
1909 r = ERROR_INVALID_DATA;
1910 }
1911
1912 return r;
1913 }
1914
1915 static UINT TABLE_delete( struct tagMSIVIEW *view )
1916 {
1917 struct table_view *tv = (struct table_view *)view;
1918
1919 TRACE("%p\n", view );
1920
1921 tv->table = NULL;
1922 tv->columns = NULL;
1923
1924 free( tv );
1925
1926 return ERROR_SUCCESS;
1927 }
1928
1929 static UINT TABLE_add_ref(struct tagMSIVIEW *view)
1930 {
1931 struct table_view *tv = (struct table_view *)view;
1932
1933 TRACE( "%p, %ld\n", view, tv->table->ref_count );
1934 return InterlockedIncrement(&tv->table->ref_count);
1935 }
1936
1937 static UINT TABLE_remove_column(struct tagMSIVIEW *view, UINT number)
1938 {
1939 struct table_view *tv = (struct table_view *)view;
1940 MSIRECORD *rec = NULL;
1941 MSIVIEW *columns = NULL;
1942 UINT row, r;
1943
1944 if (tv->table->col_count != number)
1945 return ERROR_BAD_QUERY_SYNTAX;
1946
1947 if (tv->table->colinfo[number-1].type & MSITYPE_TEMPORARY)
1948 {
1949 UINT size = tv->table->colinfo[number-1].offset;
1950 tv->table->col_count--;
1951 tv->table->colinfo = realloc(tv->table->colinfo, sizeof(*tv->table->colinfo) * tv->table->col_count);
1952
1953 for (row = 0; row < tv->table->row_count; row++)
1954 tv->table->data[row] = realloc(tv->table->data[row], size);
1955 return ERROR_SUCCESS;
1956 }
1957
1958 rec = MSI_CreateRecord(2);
1959 if (!rec)
1960 return ERROR_OUTOFMEMORY;
1961
1962 MSI_RecordSetStringW(rec, 1, tv->name);
1963 MSI_RecordSetInteger(rec, 2, number);
1964
1965 r = TABLE_CreateView(tv->db, L"_Columns", &columns);
1966 if (r != ERROR_SUCCESS)
1967 {
1968 msiobj_release(&rec->hdr);
1969 return r;
1970 }
1971
1972 r = table_find_row((struct table_view *)columns, rec, &row, NULL);
1973 if (r != ERROR_SUCCESS)
1974 goto done;
1975
1976 r = TABLE_delete_row(columns, row);
1977 if (r != ERROR_SUCCESS)
1978 goto done;
1979
1980 update_table_columns(tv->db, tv->name);
1981
1982 done:
1983 msiobj_release(&rec->hdr);
1984 columns->ops->delete(columns);
1985 return r;
1986 }
1987
1988 static UINT TABLE_release(struct tagMSIVIEW *view)
1989 {
1990 struct table_view *tv = (struct table_view *)view;
1991 INT ref = tv->table->ref_count;
1992 UINT r;
1993 INT i;
1994
1995 TRACE("%p %d\n", view, ref);
1996
1997 ref = InterlockedDecrement(&tv->table->ref_count);
1998 if (ref == 0)
1999 {
2000 for (i = tv->table->col_count - 1; i >= 0; i--)
2001 {
2002 if (tv->table->colinfo[i].type & MSITYPE_TEMPORARY)
2003 {
2004 r = TABLE_remove_column(view, tv->table->colinfo[i].number);
2005 if (r != ERROR_SUCCESS)
2006 break;
2007 }
2008 else
2009 {
2010 break;
2011 }
2012 }
2013
2014 if (!tv->table->col_count)
2015 {
2016 list_remove(&tv->table->entry);
2017 free_table(tv->table);
2018 TABLE_delete(view);
2019 }
2020 }
2021
2022 return ref;
2023 }
2024
2025 static UINT TABLE_add_column(struct tagMSIVIEW *view, LPCWSTR column,
2026 INT type, BOOL hold)
2027 {
2028 UINT i, r, table_id, col_id, size, offset;
2029 BOOL temporary = type & MSITYPE_TEMPORARY;
2030 struct table_view *tv = (struct table_view *)view;
2031 struct column_info *colinfo;
2032
2033 if (temporary && !hold && !tv->table->ref_count)
2034 return ERROR_SUCCESS;
2035
2036 if (!temporary && tv->table->col_count &&
2037 tv->table->colinfo[tv->table->col_count-1].type & MSITYPE_TEMPORARY)
2038 return ERROR_BAD_QUERY_SYNTAX;
2039
2040 for (i = 0; i < tv->table->col_count; i++)
2041 {
2042 if (!wcscmp(tv->table->colinfo[i].colname, column))
2043 return ERROR_BAD_QUERY_SYNTAX;
2044 }
2045
2046 colinfo = realloc(tv->table->colinfo, sizeof(*tv->table->colinfo) * (tv->table->col_count + 1));
2047 if (!colinfo)
2048 return ERROR_OUTOFMEMORY;
2049 tv->table->colinfo = colinfo;
2050
2051 r = msi_string2id( tv->db->strings, tv->name, -1, &table_id );
2052 if (r != ERROR_SUCCESS)
2053 return r;
2054 col_id = msi_add_string( tv->db->strings, column, -1, !temporary );
2055
2056 colinfo[tv->table->col_count].tablename = msi_string_lookup( tv->db->strings, table_id, NULL );
2057 colinfo[tv->table->col_count].number = tv->table->col_count + 1;
2058 colinfo[tv->table->col_count].colname = msi_string_lookup( tv->db->strings, col_id, NULL );
2059 colinfo[tv->table->col_count].type = type;
2060 colinfo[tv->table->col_count].offset = 0;
2061 colinfo[tv->table->col_count].hash_table = NULL;
2062 tv->table->col_count++;
2063
2064 table_calc_column_offsets( tv->db, tv->table->colinfo, tv->table->col_count);
2065
2066 size = table_get_row_size( tv->db, tv->table->colinfo, tv->table->col_count, LONG_STR_BYTES );
2067 offset = tv->table->colinfo[tv->table->col_count - 1].offset;
2068 for (i = 0; i < tv->table->row_count; i++)
2069 {
2070 BYTE *data = realloc(tv->table->data[i], size);
2071 if (!data)
2072 {
2073 tv->table->col_count--;
2074 return ERROR_OUTOFMEMORY;
2075 }
2076
2077 tv->table->data[i] = data;
2078 memset(data + offset, 0, size - offset);
2079 }
2080
2081 if (!temporary)
2082 {
2083 MSIVIEW *columns;
2084 MSIRECORD *rec;
2085
2086 rec = MSI_CreateRecord(4);
2087 if (!rec)
2088 {
2089 tv->table->col_count--;
2090 return ERROR_OUTOFMEMORY;
2091 }
2092
2093 MSI_RecordSetStringW(rec, 1, tv->name);
2094 MSI_RecordSetInteger(rec, 2, tv->table->col_count);
2095 MSI_RecordSetStringW(rec, 3, column);
2096 MSI_RecordSetInteger(rec, 4, type);
2097
2098 r = TABLE_CreateView(tv->db, L"_Columns", &columns);
2099 if (r != ERROR_SUCCESS)
2100 {
2101 tv->table->col_count--;
2102 msiobj_release(&rec->hdr);
2103 return r;
2104 }
2105
2106 r = TABLE_insert_row(columns, rec, -1, FALSE);
2107 columns->ops->delete(columns);
2108 msiobj_release(&rec->hdr);
2109 if (r != ERROR_SUCCESS)
2110 {
2111 tv->table->col_count--;
2112 return r;
2113 }
2114 }
2115 if (hold)
2116 TABLE_add_ref(view);
2117 return ERROR_SUCCESS;
2118 }
2119
2120 static UINT TABLE_drop(struct tagMSIVIEW *view)
2121 {
2122 struct table_view *tv = (struct table_view *)view;
2123 MSIVIEW *tables = NULL;
2124 MSIRECORD *rec = NULL;
2125 UINT r, row;
2126 INT i;
2127
2128 TRACE("dropping table %s\n", debugstr_w(tv->name));
2129
2130 for (i = tv->table->col_count - 1; i >= 0; i--)
2131 {
2132 r = TABLE_remove_column(view, tv->table->colinfo[i].number);
2133 if (r != ERROR_SUCCESS)
2134 return r;
2135 }
2136
2137 rec = MSI_CreateRecord(1);
2138 if (!rec)
2139 return ERROR_OUTOFMEMORY;
2140
2141 MSI_RecordSetStringW(rec, 1, tv->name);
2142
2143 r = TABLE_CreateView(tv->db, L"_Tables", &tables);
2144 if (r != ERROR_SUCCESS)
2145 {
2146 msiobj_release(&rec->hdr);
2147 return r;
2148 }
2149
2150 r = table_find_row((struct table_view *)tables, rec, &row, NULL);
2151 if (r != ERROR_SUCCESS)
2152 goto done;
2153
2154 r = TABLE_delete_row(tables, row);
2155 if (r != ERROR_SUCCESS)
2156 goto done;
2157
2158 list_remove(&tv->table->entry);
2159 free_table(tv->table);
2160
2161 done:
2162 msiobj_release(&rec->hdr);
2163 tables->ops->delete(tables);
2164
2165 return r;
2166 }
2167
2168 static const MSIVIEWOPS table_ops =
2169 {
2170 TABLE_fetch_int,
2171 TABLE_fetch_stream,
2172 TABLE_set_int,
2173 TABLE_set_string,
2174 TABLE_set_stream,
2175 TABLE_set_row,
2176 TABLE_insert_row,
2177 TABLE_delete_row,
2178 TABLE_execute,
2179 TABLE_close,
2180 TABLE_get_dimensions,
2181 TABLE_get_column_info,
2182 TABLE_modify,
2183 TABLE_delete,
2184 TABLE_add_ref,
2185 TABLE_release,
2186 TABLE_add_column,
2187 NULL,
2188 TABLE_drop,
2189 };
2190
2191 UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
2192 {
2193 struct table_view *tv ;
2194 UINT r, sz;
2195
2196 TRACE("%p %s %p\n", db, debugstr_w(name), view );
2197
2198 if ( !wcscmp( name, L"_Streams" ) )
2199 return STREAMS_CreateView( db, view );
2200 else if ( !wcscmp( name, L"_Storages" ) )
2201 return STORAGES_CreateView( db, view );
2202
2203 sz = FIELD_OFFSET( struct table_view, name[lstrlenW( name ) + 1] );
2204 tv = calloc( 1, sz );
2205 if( !tv )
2206 return ERROR_FUNCTION_FAILED;
2207
2208 r = get_table( db, name, &tv->table );
2209 if( r != ERROR_SUCCESS )
2210 {
2211 free( tv );
2212 WARN("table not found\n");
2213 return r;
2214 }
2215
2216 TRACE("table %p found with %d columns\n", tv->table, tv->table->col_count);
2217
2218 /* fill the structure */
2219 tv->view.ops = &table_ops;
2220 tv->db = db;
2221 tv->columns = tv->table->colinfo;
2222 tv->num_cols = tv->table->col_count;
2223 tv->row_size = table_get_row_size( db, tv->table->colinfo, tv->table->col_count, LONG_STR_BYTES );
2224
2225 TRACE("%s one row is %d bytes\n", debugstr_w(name), tv->row_size );
2226
2227 *view = (MSIVIEW*) tv;
2228 lstrcpyW( tv->name, name );
2229
2230 return ERROR_SUCCESS;
2231 }
2232
2233 static WCHAR *create_key_string(struct table_view *tv, MSIRECORD *rec)
2234 {
2235 DWORD i, p, len, key_len = 0;
2236 WCHAR *key;
2237
2238 for (i = 0; i < tv->num_cols; i++)
2239 {
2240 if (!(tv->columns[i].type & MSITYPE_KEY))
2241 continue;
2242 if (MSI_RecordGetStringW( rec, i+1, NULL, &len ) == ERROR_SUCCESS)
2243 key_len += len;
2244 key_len++;
2245 }
2246
2247 key = malloc( key_len * sizeof(WCHAR) );
2248 if(!key)
2249 return NULL;
2250
2251 p = 0;
2252 for (i = 0; i < tv->num_cols; i++)
2253 {
2254 if (!(tv->columns[i].type & MSITYPE_KEY))
2255 continue;
2256 if (p)
2257 key[p++] = '\t';
2258 len = key_len - p;
2259 if (MSI_RecordGetStringW( rec, i+1, key + p, &len ) == ERROR_SUCCESS)
2260 p += len;
2261 }
2262 return key;
2263 }
2264
2265 static UINT record_stream_name( const struct table_view *tv, MSIRECORD *rec, WCHAR *name, DWORD *len )
2266 {
2267 UINT p = 0, i, r;
2268 DWORD l;
2269
2270 l = wcslen( tv->name );
2271 if (name && *len > l)
2272 memcpy(name, tv->name, l * sizeof(WCHAR));
2273 p += l;
2274
2275 for ( i = 0; i < tv->num_cols; i++ )
2276 {
2277 if (!(tv->columns[i].type & MSITYPE_KEY))
2278 continue;
2279
2280 if (name && *len > p + 1)
2281 name[p] = '.';
2282 p++;
2283
2284 l = (*len > p ? *len - p : 0);
2285 r = MSI_RecordGetStringW( rec, i + 1, name ? name + p : NULL, &l );
2286 if (r != ERROR_SUCCESS)
2287 return r;
2288 p += l;
2289 }
2290
2291 if (name && *len > p)
2292 name[p] = 0;
2293
2294 *len = p;
2295 return ERROR_SUCCESS;
2296 }
2297
2298 static UINT TransformView_fetch_int( MSIVIEW *view, UINT row, UINT col, UINT *val )
2299 {
2300 struct table_view *tv = (struct table_view *)view;
2301
2302 if (!tv->table || col > tv->table->col_count)
2303 {
2304 *val = 0;
2305 return ERROR_SUCCESS;
2306 }
2307 return TABLE_fetch_int( view, row, col, val );
2308 }
2309
2310 static UINT TransformView_fetch_stream( MSIVIEW *view, UINT row, UINT col, IStream **stm )
2311 {
2312 struct table_view *tv = (struct table_view *)view;
2313
2314 if (!tv->table || col > tv->table->col_count)
2315 {
2316 *stm = NULL;
2317 return ERROR_SUCCESS;
2318 }
2319 return TABLE_fetch_stream( view, row, col, stm );
2320 }
2321
2322 static UINT TransformView_set_row( MSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask )
2323 {
2324 static const WCHAR query_pfx[] =
2325 L"INSERT INTO `_TransformView` (`new`, `Table`, `Column`, `Row`, `Data`, `Current`) VALUES (1, '";
2326
2327 struct table_view *tv = (struct table_view *)view;
2328 WCHAR buf[256], *query;
2329 MSIRECORD *old_rec;
2330 MSIQUERY *q;
2331 WCHAR *key;
2332 UINT i, p, r, qlen;
2333 DWORD len;
2334
2335 if (!wcscmp( tv->name, L"_Columns" ))
2336 {
2337 ERR( "trying to modify existing column\n" );
2338 return ERROR_INSTALL_TRANSFORM_FAILURE;
2339 }
2340
2341 if (!wcscmp( tv->name, L"_Tables" ))
2342 {
2343 ERR( "trying to modify existing table\n" );
2344 return ERROR_INSTALL_TRANSFORM_FAILURE;
2345 }
2346
2347 key = create_key_string( tv, rec );
2348 if (!key)
2349 return ERROR_OUTOFMEMORY;
2350
2351 r = msi_view_get_row( tv->db, view, row, &old_rec );
2352 if (r != ERROR_SUCCESS)
2353 old_rec = NULL;
2354
2355 for (i = 0; i < tv->num_cols; i++)
2356 {
2357 if (!(mask & (1 << i)))
2358 continue;
2359 if (tv->columns[i].type & MSITYPE_KEY)
2360 continue;
2361
2362 qlen = p = ARRAY_SIZE( query_pfx ) - 1;
2363 qlen += wcslen( tv->name ) + 3; /* strlen("','") */
2364 qlen += wcslen( tv->columns[i].colname ) + 3;
2365 qlen += wcslen( key ) + 3;
2366 if (MSITYPE_IS_BINARY( tv->columns[i].type ))
2367 r = record_stream_name( tv, rec, NULL, &len );
2368 else
2369 r = MSI_RecordGetStringW( rec, i + 1, NULL, &len );
2370 if (r != ERROR_SUCCESS)
2371 {
2372 if (old_rec)
2373 msiobj_release( &old_rec->hdr );
2374 free( key );
2375 return r;
2376 }
2377 qlen += len + 3;
2378 if (old_rec && (r = MSI_RecordGetStringW( old_rec, i+1, NULL, &len )))
2379 {
2380 msiobj_release( &old_rec->hdr );
2381 free( key );
2382 return r;
2383 }
2384 qlen += len + 3; /* strlen("')") + 1 */
2385
2386 if (qlen > ARRAY_SIZE(buf))
2387 {
2388 query = malloc( qlen * sizeof(WCHAR) );
2389 if (!query)
2390 {
2391 if (old_rec)
2392 msiobj_release( &old_rec->hdr );
2393 free( key );
2394 return ERROR_OUTOFMEMORY;
2395 }
2396 }
2397 else
2398 {
2399 query = buf;
2400 }
2401
2402 memcpy( query, query_pfx, p * sizeof(WCHAR) );
2403 len = wcslen( tv->name );
2404 memcpy( query + p, tv->name, len * sizeof(WCHAR) );
2405 p += len;
2406 query[p++] = '\'';
2407 query[p++] = ',';
2408 query[p++] = '\'';
2409 len = wcslen( tv->columns[i].colname );
2410 memcpy( query + p, tv->columns[i].colname, len * sizeof(WCHAR) );
2411 p += len;
2412 query[p++] = '\'';
2413 query[p++] = ',';
2414 query[p++] = '\'';
2415 len = wcslen( key );
2416 memcpy( query + p, key, len * sizeof(WCHAR) );
2417 p += len;
2418 query[p++] = '\'';
2419 query[p++] = ',';
2420 query[p++] = '\'';
2421 len = qlen - p;
2422 if (MSITYPE_IS_BINARY( tv->columns[i].type ))
2423 record_stream_name( tv, rec, query + p, &len );
2424 else
2425 MSI_RecordGetStringW( rec, i + 1, query + p, &len );
2426 p += len;
2427 query[p++] = '\'';
2428 query[p++] = ',';
2429 query[p++] = '\'';
2430 if (old_rec)
2431 {
2432 len = qlen - p;
2433 MSI_RecordGetStringW( old_rec, i + 1, query + p, &len );
2434 p += len;
2435 }
2436 query[p++] = '\'';
2437 query[p++] = ')';
2438 query[p++] = 0;
2439
2440 r = MSI_DatabaseOpenViewW( tv->db, query, &q );
2441 if (query != buf)
2442 free( query );
2443 if (r != ERROR_SUCCESS)
2444 {
2445 if (old_rec)
2446 msiobj_release( &old_rec->hdr );
2447 free( key );
2448 return r;
2449 }
2450
2451 r = MSI_ViewExecute( q, NULL );
2452 msiobj_release( &q->hdr );
2453 if (r != ERROR_SUCCESS)
2454 {
2455 if (old_rec)
2456 msiobj_release( &old_rec->hdr );
2457 free( key );
2458 return r;
2459 }
2460 }
2461
2462 if (old_rec)
2463 msiobj_release( &old_rec->hdr );
2464 free( key );
2465 return ERROR_SUCCESS;
2466 }
2467
2468 static UINT TransformView_create_table( struct table_view *tv, MSIRECORD *rec )
2469 {
2470 static const WCHAR query_fmt[] =
2471 L"INSERT INTO `_TransformView` (`Table`, `Column`, `new`) VALUES ('%s', 'CREATE', 1)";
2472
2473 WCHAR buf[256], *query = buf;
2474 const WCHAR *name;
2475 MSIQUERY *q;
2476 int len;
2477 UINT r;
2478
2479 name = msi_record_get_string( rec, 1, &len );
2480 if (!name)
2481 return ERROR_INSTALL_TRANSFORM_FAILURE;
2482
2483 len = _snwprintf( NULL, 0, query_fmt, name ) + 1;
2484 if (len > ARRAY_SIZE(buf))
2485 {
2486 query = malloc( len * sizeof(WCHAR) );
2487 if (!query)
2488 return ERROR_OUTOFMEMORY;
2489 }
2490 swprintf( query, len, query_fmt, name );
2491
2492 r = MSI_DatabaseOpenViewW( tv->db, query, &q );
2493 if (query != buf)
2494 free( query );
2495 if (r != ERROR_SUCCESS)
2496 return r;
2497
2498 r = MSI_ViewExecute( q, NULL );
2499 msiobj_release( &q->hdr );
2500 return r;
2501 }
2502
2503 static UINT TransformView_add_column( struct table_view *tv, MSIRECORD *rec )
2504 {
2505 static const WCHAR query_pfx[] =
2506 L"INSERT INTO `_TransformView` (`new`, `Table`, `Current`, `Column`, `Data`) VALUES (1, '";
2507
2508 WCHAR buf[256], *query = buf;
2509 UINT i, p, r, qlen;
2510 DWORD len;
2511 MSIQUERY *q;
2512
2513 qlen = p = wcslen( query_pfx );
2514 for (i = 1; i <= 4; i++)
2515 {
2516 r = MSI_RecordGetStringW( rec, i, NULL, &len );
2517 if (r != ERROR_SUCCESS)
2518 return r;
2519 qlen += len + 3; /* strlen( "','" ) */
2520 }
2521
2522 if (qlen > ARRAY_SIZE(buf))
2523 {
2524 query = malloc( len * sizeof(WCHAR) );
2525 qlen = len;
2526 if (!query)
2527 return ERROR_OUTOFMEMORY;
2528 }
2529
2530 memcpy( query, query_pfx, p * sizeof(WCHAR) );
2531 for (i = 1; i <= 4; i++)
2532 {
2533 len = qlen - p;
2534 MSI_RecordGetStringW( rec, i, query + p, &len );
2535 p += len;
2536 query[p++] = '\'';
2537 if (i != 4)
2538 {
2539 query[p++] = ',';
2540 query[p++] = '\'';
2541 }
2542 }
2543 query[p++] = ')';
2544 query[p++] = 0;
2545
2546 r = MSI_DatabaseOpenViewW( tv->db, query, &q );
2547 if (query != buf)
2548 free( query );
2549 if (r != ERROR_SUCCESS)
2550 return r;
2551
2552 r = MSI_ViewExecute( q, NULL );
2553 msiobj_release( &q->hdr );
2554 return r;
2555 }
2556
2557 static UINT TransformView_insert_row( MSIVIEW *view, MSIRECORD *rec, UINT row, BOOL temporary )
2558 {
2559 static const WCHAR query_fmt[] =
2560 L"INSERT INTO `_TransformView` (`new`, `Table`, `Column`, `Row`) VALUES (1, '%s', 'INSERT', '%s')";
2561
2562 struct table_view *tv = (struct table_view *)view;
2563 WCHAR buf[256], *query = buf;
2564 MSIQUERY *q;
2565 WCHAR *key;
2566 int len;
2567 UINT r;
2568
2569 if (!wcscmp(tv->name, L"_Tables"))
2570 return TransformView_create_table( tv, rec );
2571
2572 if (!wcscmp(tv->name, L"_Columns"))
2573 return TransformView_add_column( tv, rec );
2574
2575 key = create_key_string( tv, rec );
2576 if (!key)
2577 return ERROR_OUTOFMEMORY;
2578
2579 len = _snwprintf( NULL, 0, query_fmt, tv->name, key ) + 1;
2580 if (len > ARRAY_SIZE(buf))
2581 {
2582 query = malloc( len * sizeof(WCHAR) );
2583 if (!query)
2584 {
2585 free( key );
2586 return ERROR_OUTOFMEMORY;
2587 }
2588 }
2589 swprintf( query, len, query_fmt, tv->name, key );
2590 free( key );
2591
2592 r = MSI_DatabaseOpenViewW( tv->db, query, &q );
2593 if (query != buf)
2594 free( query );
2595 if (r != ERROR_SUCCESS)
2596 return r;
2597
2598 r = MSI_ViewExecute( q, NULL );
2599 msiobj_release( &q->hdr );
2600 if (r != ERROR_SUCCESS)
2601 return r;
2602
2603 return TransformView_set_row( view, row, rec, ~0 );
2604 }
2605
2606 static UINT TransformView_drop_table( struct table_view *tv, UINT row )
2607 {
2608 static const WCHAR query_pfx[] = L"INSERT INTO `_TransformView` ( `new`, `Table`, `Column` ) VALUES ( 1, '";
2609 static const WCHAR query_sfx[] = L"', 'DROP' )";
2610
2611 WCHAR buf[256], *query = buf;
2612 UINT r, table_id, len;
2613 const WCHAR *table;
2614 int table_len;
2615 MSIQUERY *q;
2616
2617 r = TABLE_fetch_int( &tv->view, row, 1, &table_id );
2618 if (r != ERROR_SUCCESS)
2619 return r;
2620
2621 table = msi_string_lookup( tv->db->strings, table_id, &table_len );
2622 if (!table)
2623 return ERROR_INSTALL_TRANSFORM_FAILURE;
2624
2625 len = ARRAY_SIZE(query_pfx) - 1 + table_len + ARRAY_SIZE(query_sfx);
2626 if (len > ARRAY_SIZE(buf))
2627 {
2628 query = malloc( len * sizeof(WCHAR) );
2629 if (!query)
2630 return ERROR_OUTOFMEMORY;
2631 }
2632
2633 memcpy( query, query_pfx, ARRAY_SIZE(query_pfx) * sizeof(WCHAR) );
2634 len = ARRAY_SIZE(query_pfx) - 1;
2635 memcpy( query + len, table, table_len * sizeof(WCHAR) );
2636 len += table_len;
2637 memcpy( query + len, query_sfx, ARRAY_SIZE(query_sfx) * sizeof(WCHAR) );
2638
2639 r = MSI_DatabaseOpenViewW( tv->db, query, &q );
2640 if (query != buf)
2641 free( query );
2642 if (r != ERROR_SUCCESS)
2643 return r;
2644
2645 r = MSI_ViewExecute( q, NULL );
2646 msiobj_release( &q->hdr );
2647 return r;
2648 }
2649
2650 static UINT TransformView_delete_row( MSIVIEW *view, UINT row )
2651 {
2652 static const WCHAR query_pfx[] = L"INSERT INTO `_TransformView` ( `new`, `Table`, `Column`, `Row`) VALUES ( 1, '";
2653 static const WCHAR query_column[] = L"', 'DELETE', '";
2654 static const WCHAR query_sfx[] = L"')";
2655
2656 struct table_view *tv = (struct table_view *)view;
2657 WCHAR *key, buf[256], *query = buf;
2658 UINT r, len, name_len, key_len;
2659 MSIRECORD *rec;
2660 MSIQUERY *q;
2661
2662 if (!wcscmp( tv->name, L"_Columns" ))
2663 {
2664 ERR("trying to remove column\n");
2665 return ERROR_INSTALL_TRANSFORM_FAILURE;
2666 }
2667
2668 if (!wcscmp( tv->name, L"_Tables" ))
2669 return TransformView_drop_table( tv, row );
2670
2671 r = msi_view_get_row( tv->db, view, row, &rec );
2672 if (r != ERROR_SUCCESS)
2673 return r;
2674
2675 key = create_key_string( tv, rec );
2676 msiobj_release( &rec->hdr );
2677 if (!key)
2678 return ERROR_OUTOFMEMORY;
2679
2680 name_len = wcslen( tv->name );
2681 key_len = wcslen( key );
2682 len = ARRAY_SIZE(query_pfx) + name_len + ARRAY_SIZE(query_column) + key_len + ARRAY_SIZE(query_sfx) - 2;
2683 if (len > ARRAY_SIZE(buf))
2684 {
2685 query = malloc( len * sizeof(WCHAR) );
2686 if (!query)
2687 {
2688 free( tv );
2689 free( key );
2690 return ERROR_OUTOFMEMORY;
2691 }
2692 }
2693
2694 memcpy( query, query_pfx, ARRAY_SIZE(query_pfx) * sizeof(WCHAR) );
2695 len = ARRAY_SIZE(query_pfx) - 1;
2696 memcpy( query + len, tv->name, name_len * sizeof(WCHAR) );
2697 len += name_len;
2698 memcpy( query + len, query_column, ARRAY_SIZE(query_column) * sizeof(WCHAR) );
2699 len += ARRAY_SIZE(query_column) - 1;
2700 memcpy( query + len, key, key_len * sizeof(WCHAR) );
2701 len += key_len;
2702 memcpy( query + len, query_sfx, ARRAY_SIZE(query_sfx) * sizeof(WCHAR) );
2703 free( key );
2704
2705 r = MSI_DatabaseOpenViewW( tv->db, query, &q );
2706 if (query != buf)
2707 free( query );
2708 if (r != ERROR_SUCCESS)
2709 return r;
2710
2711 r = MSI_ViewExecute( q, NULL );
2712 msiobj_release( &q->hdr );
2713 return r;
2714 }
2715
2716 static UINT TransformView_execute( MSIVIEW *view, MSIRECORD *record )
2717 {
2718 return ERROR_SUCCESS;
2719 }
2720
2721 static UINT TransformView_close( MSIVIEW *view )
2722 {
2723 return ERROR_SUCCESS;
2724 }
2725
2726 static UINT TransformView_get_dimensions( MSIVIEW *view, UINT *rows, UINT *cols )
2727 {
2728 return TABLE_get_dimensions( view, rows, cols );
2729 }
2730
2731 static UINT TransformView_get_column_info( MSIVIEW *view, UINT n, LPCWSTR *name, UINT *type,
2732 BOOL *temporary, LPCWSTR *table_name )
2733 {
2734 return TABLE_get_column_info( view, n, name, type, temporary, table_name );
2735 }
2736
2737 static UINT TransformView_delete( MSIVIEW *view )
2738 {
2739 struct table_view *tv = (struct table_view *)view;
2740 if (!tv->table || tv->columns != tv->table->colinfo)
2741 free( tv->columns );
2742 return TABLE_delete( view );
2743 }
2744
2745 static const MSIVIEWOPS transform_view_ops =
2746 {
2747 TransformView_fetch_int,
2748 TransformView_fetch_stream,
2749 NULL,
2750 NULL,
2751 NULL,
2752 TransformView_set_row,
2753 TransformView_insert_row,
2754 TransformView_delete_row,
2755 TransformView_execute,
2756 TransformView_close,
2757 TransformView_get_dimensions,
2758 TransformView_get_column_info,
2759 NULL,
2760 TransformView_delete,
2761 NULL,
2762 NULL,
2763 NULL,
2764 NULL,
2765 NULL
2766 };
2767
2768 UINT TransformView_Create( MSIDATABASE *db, string_table *st, LPCWSTR name, MSIVIEW **view )
2769 {
2770 static const WCHAR query_pfx[] = L"SELECT `Column`, `Data`, `Current` FROM `_TransformView` WHERE `Table`='";
2771 static const WCHAR query_sfx[] = L"' AND `Row` IS NULL AND `Current` IS NOT NULL AND `new` = 1";
2772
2773 WCHAR buf[256], *query = buf;
2774 UINT r, len, name_len, size, add_col;
2775 struct column_info *colinfo;
2776 struct table_view *tv;
2777 MSIRECORD *rec;
2778 MSIQUERY *q;
2779
2780 name_len = wcslen( name );
2781
2782 r = TABLE_CreateView( db, name, view );
2783 if (r == ERROR_INVALID_PARAMETER)
2784 {
2785 /* table does not exist */
2786 size = FIELD_OFFSET( struct table_view, name[name_len + 1] );
2787 tv = calloc( 1, size );
2788 if (!tv)
2789 return ERROR_OUTOFMEMORY;
2790
2791 tv->db = db;
2792 memcpy( tv->name, name, name_len * sizeof(WCHAR) );
2793 *view = (MSIVIEW*)tv;
2794 }
2795 else if (r != ERROR_SUCCESS)
2796 {
2797 return r;
2798 }
2799 else
2800 {
2801 tv = (struct table_view *)*view;
2802 }
2803
2804 tv->view.ops = &transform_view_ops;
2805
2806 len = ARRAY_SIZE(query_pfx) + name_len + ARRAY_SIZE(query_sfx) - 1;
2807 if (len > ARRAY_SIZE(buf))
2808 {
2809 query = malloc( len * sizeof(WCHAR) );
2810 if (!query)
2811 {
2812 free( tv );
2813 return ERROR_OUTOFMEMORY;
2814 }
2815 }
2816 memcpy( query, query_pfx, ARRAY_SIZE(query_pfx) * sizeof(WCHAR) );
2817 len = ARRAY_SIZE(query_pfx) - 1;
2818 memcpy( query + len, name, name_len * sizeof(WCHAR) );
2819 len += name_len;
2820 memcpy( query + len, query_sfx, ARRAY_SIZE(query_sfx) * sizeof(WCHAR) );
2821
2822 r = MSI_DatabaseOpenViewW( tv->db, query, &q );
2823 if (query != buf)
2824 free( query );
2825 if (r != ERROR_SUCCESS)
2826 {
2827 free( tv );
2828 return r;
2829 }
2830
2831 r = MSI_ViewExecute( q, NULL );
2832 if (r != ERROR_SUCCESS)
2833 {
2834 free( tv );
2835 return r;
2836 }
2837
2838 r = q->view->ops->get_dimensions( q->view, &add_col, NULL );
2839 if (r != ERROR_SUCCESS)
2840 {
2841 MSI_ViewClose( q );
2842 msiobj_release( &q->hdr );
2843 free( tv );
2844 return r;
2845 }
2846 if (!add_col)
2847 {
2848 MSI_ViewClose( q );
2849 msiobj_release( &q->hdr );
2850 return ERROR_SUCCESS;
2851 }
2852
2853 colinfo = calloc( add_col + tv->num_cols, sizeof(*colinfo) );
2854 if (!colinfo)
2855 {
2856 MSI_ViewClose( q );
2857 msiobj_release( &q->hdr );
2858 free( tv );
2859 return ERROR_OUTOFMEMORY;
2860 }
2861
2862 while (MSI_ViewFetch( q, &rec ) == ERROR_SUCCESS)
2863 {
2864 int name_len;
2865 const WCHAR *name = msi_record_get_string( rec, 1, &name_len );
2866 const WCHAR *type = msi_record_get_string( rec, 2, NULL );
2867 UINT name_id, idx;
2868
2869 idx = _wtoi( msi_record_get_string(rec, 3, NULL) );
2870 colinfo[idx - 1].number = idx;
2871 colinfo[idx - 1].type = _wtoi( type );
2872
2873 r = msi_string2id( st, name, name_len, &name_id );
2874 if (r == ERROR_SUCCESS)
2875 colinfo[idx - 1].colname = msi_string_lookup( st, name_id, NULL );
2876 else
2877 ERR( "column name %s is not defined in strings table\n", wine_dbgstr_w(name) );
2878 msiobj_release( &rec->hdr );
2879 }
2880 MSI_ViewClose( q );
2881 msiobj_release( &q->hdr );
2882
2883 memcpy( colinfo, tv->columns, tv->num_cols * sizeof(*colinfo) );
2884 tv->columns = colinfo;
2885 tv->num_cols += add_col;
2886 return ERROR_SUCCESS;
2887 }
2888
2889 UINT MSI_CommitTables( MSIDATABASE *db )
2890 {
2891 UINT r, bytes_per_strref;
2892 HRESULT hr;
2893 MSITABLE *table = NULL;
2894
2895 TRACE("%p\n",db);
2896
2897 r = msi_save_string_table( db->strings, db->storage, &bytes_per_strref );
2898 if( r != ERROR_SUCCESS )
2899 {
2900 WARN("failed to save string table r=%08x\n",r);
2901 return r;
2902 }
2903
2904 LIST_FOR_EACH_ENTRY( table, &db->tables, MSITABLE, entry )
2905 {
2906 r = save_table( db, table, bytes_per_strref );
2907 if( r != ERROR_SUCCESS )
2908 {
2909 WARN("failed to save table %s (r=%08x)\n",
2910 debugstr_w(table->name), r);
2911 return r;
2912 }
2913 }
2914
2915 hr = IStorage_Commit( db->storage, 0 );
2916 if (FAILED( hr ))
2917 {
2918 WARN( "failed to commit changes %#lx\n", hr );
2919 r = ERROR_FUNCTION_FAILED;
2920 }
2921 return r;
2922 }
2923
2924 MSICONDITION MSI_DatabaseIsTablePersistent( MSIDATABASE *db, LPCWSTR table )
2925 {
2926 MSITABLE *t;
2927 UINT r;
2928
2929 TRACE("%p %s\n", db, debugstr_w(table));
2930
2931 if (!table)
2932 return MSICONDITION_ERROR;
2933
2934 r = get_table( db, table, &t );
2935 if (r != ERROR_SUCCESS)
2936 return MSICONDITION_NONE;
2937
2938 return t->persistent;
2939 }
2940
2941 static UINT read_raw_int(const BYTE *data, UINT col, UINT bytes)
2942 {
2943 UINT ret = 0, i;
2944
2945 for (i = 0; i < bytes; i++)
2946 ret += (data[col + i] << i * 8);
2947
2948 return ret;
2949 }
2950
2951 static UINT record_encoded_stream_name( const struct table_view *tv, MSIRECORD *rec, WCHAR **pstname )
2952 {
2953 UINT r;
2954 DWORD len;
2955 WCHAR *name;
2956
2957 TRACE("%p %p\n", tv, rec);
2958
2959 r = record_stream_name( tv, rec, NULL, &len );
2960 if (r != ERROR_SUCCESS)
2961 return r;
2962 len++;
2963
2964 name = malloc( len * sizeof(WCHAR) );
2965 if (!name)
2966 return ERROR_OUTOFMEMORY;
2967
2968 r = record_stream_name( tv, rec, name, &len );
2969 if (r != ERROR_SUCCESS)
2970 {
2971 free( name );
2972 return r;
2973 }
2974
2975 *pstname = encode_streamname( FALSE, name );
2976 free( name );
2977 return ERROR_SUCCESS;
2978 }
2979
2980 static MSIRECORD *get_transform_record( const struct table_view *tv, const string_table *st, IStorage *stg,
2981 const BYTE *rawdata, UINT bytes_per_strref )
2982 {
2983 UINT i, val, ofs = 0;
2984 USHORT mask;
2985 struct column_info *columns = tv->columns;
2986 MSIRECORD *rec;
2987
2988 mask = rawdata[0] | (rawdata[1] << 8);
2989 rawdata += 2;
2990
2991 rec = MSI_CreateRecord( tv->num_cols );
2992 if( !rec )
2993 return rec;
2994
2995 TRACE("row ->\n");
2996 for( i=0; i<tv->num_cols; i++ )
2997 {
2998 if ( (mask&1) && (i>=(mask>>8)) )
2999 break;
3000 /* all keys must be present */
3001 if ( (~mask&1) && (~columns[i].type & MSITYPE_KEY) && ((1<<i) & ~mask) )
3002 continue;
3003
3004 if( MSITYPE_IS_BINARY(tv->columns[i].type) )
3005 {
3006 LPWSTR encname;
3007 IStream *stm = NULL;
3008 UINT r;
3009
3010 ofs += bytes_per_column( tv->db, &columns[i], bytes_per_strref );
3011
3012 r = record_encoded_stream_name( tv, rec, &encname );
3013 if ( r != ERROR_SUCCESS )
3014 {
3015 msiobj_release( &rec->hdr );
3016 return NULL;
3017 }
3018 r = IStorage_OpenStream( stg, encname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm );
3019 if ( r != ERROR_SUCCESS )
3020 {
3021 msiobj_release( &rec->hdr );
3022 free( encname );
3023 return NULL;
3024 }
3025
3026 MSI_RecordSetStream( rec, i+1, stm );
3027 TRACE(" field %d [%s]\n", i+1, debugstr_w(encname));
3028 free( encname );
3029 }
3030 else if( columns[i].type & MSITYPE_STRING )
3031 {
3032 int len;
3033 const WCHAR *sval;
3034
3035 val = read_raw_int(rawdata, ofs, bytes_per_strref);
3036 sval = msi_string_lookup( st, val, &len );
3037 msi_record_set_string( rec, i+1, sval, len );
3038 TRACE(" field %d [%s]\n", i+1, debugstr_wn(sval, len));
3039 ofs += bytes_per_strref;
3040 }
3041 else
3042 {
3043 UINT n = bytes_per_column( tv->db, &columns[i], bytes_per_strref );
3044 switch( n )
3045 {
3046 case 2:
3047 val = read_raw_int(rawdata, ofs, n);
3048 if (val)
3049 MSI_RecordSetInteger( rec, i+1, val-0x8000 );
3050 TRACE(" field %d [0x%04x]\n", i+1, val );
3051 break;
3052 case 4:
3053 val = read_raw_int(rawdata, ofs, n);
3054 if (val)
3055 MSI_RecordSetInteger( rec, i+1, val^0x80000000 );
3056 TRACE(" field %d [0x%08x]\n", i+1, val );
3057 break;
3058 default:
3059 ERR("oops - unknown column width %d\n", n);
3060 break;
3061 }
3062 ofs += n;
3063 }
3064 }
3065 return rec;
3066 }
3067
3068 static void dump_table( const string_table *st, const USHORT *rawdata, UINT rawsize )
3069 {
3070 UINT i;
3071 for (i = 0; i < rawsize / 2; i++)
3072 {
3073 int len;
3074 const WCHAR *sval = msi_string_lookup( st, rawdata[i], &len );
3075 MESSAGE(" %04x %s\n", rawdata[i], debugstr_wn(sval, len) );
3076 }
3077 }
3078
3079 static UINT *record_to_row( const struct table_view *tv, MSIRECORD *rec )
3080 {
3081 UINT i, r, *data;
3082
3083 data = malloc( tv->num_cols * sizeof (UINT) );
3084 for( i=0; i<tv->num_cols; i++ )
3085 {
3086 data[i] = 0;
3087
3088 if ( ~tv->columns[i].type & MSITYPE_KEY )
3089 continue;
3090
3091 /* turn the transform column value into a row value */
3092 if ( ( tv->columns[i].type & MSITYPE_STRING ) &&
3093 ! MSITYPE_IS_BINARY(tv->columns[i].type) )
3094 {
3095 int len;
3096 const WCHAR *str = msi_record_get_string( rec, i+1, &len );
3097 if (str)
3098 {
3099 r = msi_string2id( tv->db->strings, str, len, &data[i] );
3100
3101 /* if there's no matching string in the string table,
3102 these keys can't match any record, so fail now. */
3103 if (r != ERROR_SUCCESS)
3104 {
3105 free( data );
3106 return NULL;
3107 }
3108 }
3109 else data[i] = 0;
3110 }
3111 else
3112 {
3113 if (int_to_table_storage( tv, i + 1, MSI_RecordGetInteger( rec, i + 1 ), &data[i] ))
3114 {
3115 free( data );
3116 return NULL;
3117 }
3118 }
3119 }
3120 return data;
3121 }
3122
3123 static UINT row_matches( struct table_view *tv, UINT row, const UINT *data, UINT *column )
3124 {
3125 UINT i, r, x, ret = ERROR_FUNCTION_FAILED;
3126
3127 for( i=0; i<tv->num_cols; i++ )
3128 {
3129 if ( ~tv->columns[i].type & MSITYPE_KEY )
3130 continue;
3131
3132 /* turn the transform column value into a row value */
3133 r = TABLE_fetch_int( &tv->view, row, i+1, &x );
3134 if ( r != ERROR_SUCCESS )
3135 {
3136 ERR("TABLE_fetch_int shouldn't fail here\n");
3137 break;
3138 }
3139
3140 /* if this key matches, move to the next column */
3141 if ( x != data[i] )
3142 {
3143 ret = ERROR_FUNCTION_FAILED;
3144 break;
3145 }
3146 if (column) *column = i;
3147 ret = ERROR_SUCCESS;
3148 }
3149 return ret;
3150 }
3151
3152 static UINT table_find_row( struct table_view *tv, MSIRECORD *rec, UINT *row, UINT *column )
3153 {
3154 UINT i, r = ERROR_FUNCTION_FAILED, *data;
3155
3156 data = record_to_row( tv, rec );
3157 if( !data )
3158 return r;
3159 for( i = 0; i < tv->table->row_count; i++ )
3160 {
3161 r = row_matches( tv, i, data, column );
3162 if( r == ERROR_SUCCESS )
3163 {
3164 *row = i;
3165 break;
3166 }
3167 }
3168 free( data );
3169 return r;
3170 }
3171
3172 struct transform_data
3173 {
3174 struct list entry;
3175 LPWSTR name;
3176 };
3177
3178 static UINT table_load_transform( MSIDATABASE *db, IStorage *stg, string_table *st, struct transform_data *transform,
3179 UINT bytes_per_strref, int err_cond )
3180 {
3181 BYTE *rawdata = NULL;
3182 struct table_view *tv = NULL;
3183 UINT r, n, sz, i, mask, num_cols, colcol = 0, rawsize = 0;
3184 MSIRECORD *rec = NULL;
3185 WCHAR coltable[32];
3186 const WCHAR *name;
3187
3188 if (!transform)
3189 return ERROR_SUCCESS;
3190
3191 name = transform->name;
3192
3193 coltable[0] = 0;
3194 TRACE("%p %p %p %s\n", db, stg, st, debugstr_w(name) );
3195
3196 /* read the transform data */
3197 read_stream_data( stg, name, TRUE, &rawdata, &rawsize );
3198 if ( !rawdata )
3199 {
3200 TRACE("table %s empty\n", debugstr_w(name) );
3201 return ERROR_INVALID_TABLE;
3202 }
3203
3204 /* create a table view */
3205 if ( err_cond & MSITRANSFORM_ERROR_VIEWTRANSFORM )
3206 r = TransformView_Create( db, st, name, (MSIVIEW**) &tv );
3207 else
3208 r = TABLE_CreateView( db, name, (MSIVIEW**) &tv );
3209 if( r != ERROR_SUCCESS )
3210 goto err;
3211
3212 r = tv->view.ops->execute( &tv->view, NULL );
3213 if( r != ERROR_SUCCESS )
3214 goto err;
3215
3216 TRACE("name = %s columns = %u row_size = %u raw size = %u\n",
3217 debugstr_w(name), tv->num_cols, tv->row_size, rawsize );
3218
3219 /* interpret the data */
3220 for (n = 0; n < rawsize;)
3221 {
3222 mask = rawdata[n] | (rawdata[n + 1] << 8);
3223 if (mask & 1)
3224 {
3225 /*
3226 * if the low bit is set, columns are continuous and
3227 * the number of columns is specified in the high byte
3228 */
3229 sz = 2;
3230 num_cols = mask >> 8;
3231 if (num_cols > tv->num_cols)
3232 {
3233 ERR("excess columns in transform: %u > %u\n", num_cols, tv->num_cols);
3234 break;
3235 }
3236
3237 for (i = 0; i < num_cols; i++)
3238 {
3239 if( (tv->columns[i].type & MSITYPE_STRING) &&
3240 ! MSITYPE_IS_BINARY(tv->columns[i].type) )
3241 sz += bytes_per_strref;
3242 else
3243 sz += bytes_per_column( tv->db, &tv->columns[i], bytes_per_strref );
3244 }
3245 }
3246 else
3247 {
3248 /*
3249 * If the low bit is not set, mask is a bitmask.
3250 * Excepting for key fields, which are always present,
3251 * each bit indicates that a field is present in the transform record.
3252 *
3253 * mask == 0 is a special case ... only the keys will be present
3254 * and it means that this row should be deleted.
3255 */
3256 sz = 2;
3257 num_cols = tv->num_cols;
3258 for (i = 0; i < num_cols; i++)
3259 {
3260 if ((tv->columns[i].type & MSITYPE_KEY) || ((1 << i) & mask))
3261 {
3262 if ((tv->columns[i].type & MSITYPE_STRING) &&
3263 !MSITYPE_IS_BINARY(tv->columns[i].type))
3264 sz += bytes_per_strref;
3265 else
3266 sz += bytes_per_column( tv->db, &tv->columns[i], bytes_per_strref );
3267 }
3268 }
3269 }
3270
3271 /* check we didn't run of the end of the table */
3272 if (n + sz > rawsize)
3273 {
3274 ERR("borked.\n");
3275 dump_table( st, (USHORT *)rawdata, rawsize );
3276 break;
3277 }
3278
3279 rec = get_transform_record( tv, st, stg, &rawdata[n], bytes_per_strref );
3280 if (rec)
3281 {
3282 WCHAR table[32];
3283 DWORD sz = 32;
3284 UINT number = MSI_NULL_INTEGER;
3285 UINT row = 0;
3286
3287 if (!wcscmp( name, L"_Columns" ))
3288 {
3289 MSI_RecordGetStringW( rec, 1, table, &sz );
3290 number = MSI_RecordGetInteger( rec, 2 );
3291
3292 /*
3293 * Native msi seems writes nul into the Number (2nd) column of
3294 * the _Columns table when there are new columns
3295 */
3296 if ( number == MSI_NULL_INTEGER )
3297 {
3298 /* reset the column number on a new table */
3299 if (wcscmp( coltable, table ))
3300 {
3301 colcol = 0;
3302 lstrcpyW( coltable, table );
3303 }
3304
3305 /* fix nul column numbers */
3306 MSI_RecordSetInteger( rec, 2, ++colcol );
3307 }
3308 }
3309
3310 if (TRACE_ON(msidb)) dump_record( rec );
3311
3312 if (tv->table)
3313 r = table_find_row( tv, rec, &row, NULL );
3314 else
3315 r = ERROR_FUNCTION_FAILED;
3316 if (r == ERROR_SUCCESS)
3317 {
3318 if (!mask)
3319 {
3320 TRACE("deleting row [%d]:\n", row);
3321 r = tv->view.ops->delete_row( &tv->view, row );
3322 if (r != ERROR_SUCCESS)
3323 WARN("failed to delete row %u\n", r);
3324 }
3325 else if (mask & 1)
3326 {
3327 TRACE("modifying full row [%d]:\n", row);
3328 r = tv->view.ops->set_row( &tv->view, row, rec, (1 << tv->num_cols) - 1 );
3329 if (r != ERROR_SUCCESS)
3330 WARN("failed to modify row %u\n", r);
3331 }
3332 else
3333 {
3334 TRACE("modifying masked row [%d]:\n", row);
3335 r = tv->view.ops->set_row( &tv->view, row, rec, mask );
3336 if (r != ERROR_SUCCESS)
3337 WARN("failed to modify row %u\n", r);
3338 }
3339 }
3340 else
3341 {
3342 TRACE("inserting row\n");
3343 r = tv->view.ops->insert_row( &tv->view, rec, -1, FALSE );
3344 if (r != ERROR_SUCCESS)
3345 WARN("failed to insert row %u\n", r);
3346 }
3347
3348 if (!(err_cond & MSITRANSFORM_ERROR_VIEWTRANSFORM) && !wcscmp( name, L"_Columns" ))
3349 update_table_columns( db, table );
3350
3351 msiobj_release( &rec->hdr );
3352 }
3353
3354 n += sz;
3355 }
3356
3357 err:
3358 /* no need to free the table, it's associated with the database */
3359 free( rawdata );
3360 if( tv )
3361 tv->view.ops->delete( &tv->view );
3362
3363 return ERROR_SUCCESS;
3364 }
3365
3366 /*
3367 * msi_table_apply_transform
3368 *
3369 * Enumerate the table transforms in a transform storage and apply each one.
3370 */
3371 UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg, int err_cond )
3372 {
3373 struct list transforms;
3374 IEnumSTATSTG *stgenum = NULL;
3375 struct transform_data *transform;
3376 struct transform_data *tables = NULL, *columns = NULL;
3377 HRESULT hr;
3378 STATSTG stat;
3379 string_table *strings;
3380 UINT ret = ERROR_FUNCTION_FAILED;
3381 UINT bytes_per_strref;
3382 BOOL property_update = FALSE;
3383 MSIVIEW *transform_view = NULL;
3384
3385 TRACE("%p %p\n", db, stg );
3386
3387 strings = msi_load_string_table( stg, &bytes_per_strref );
3388 if( !strings )
3389 goto end;
3390
3391 hr = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
3392 if (FAILED( hr ))
3393 goto end;
3394
3395 list_init(&transforms);
3396
3397 while ( TRUE )
3398 {
3399 struct table_view *tv = NULL;
3400 WCHAR name[0x40];
3401 ULONG count = 0;
3402
3403 hr = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
3404 if (FAILED( hr ) || !count)
3405 break;
3406
3407 decode_streamname( stat.pwcsName, name );
3408 CoTaskMemFree( stat.pwcsName );
3409 if ( name[0] != 0x4840 )
3410 continue;
3411
3412 if ( !wcscmp( name+1, L"_StringPool" ) ||
3413 !wcscmp( name+1, L"_StringData" ) )
3414 continue;
3415
3416 transform = calloc( 1, sizeof(*transform) );
3417 if ( !transform )
3418 break;
3419
3420 list_add_tail( &transforms, &transform->entry );
3421
3422 transform->name = wcsdup( name + 1 );
3423
3424 if ( !wcscmp( transform->name, L"_Tables" ) )
3425 tables = transform;
3426 else if (!wcscmp( transform->name, L"_Columns" ) )
3427 columns = transform;
3428 else if (!wcscmp( transform->name, L"Property" ))
3429 property_update = TRUE;
3430
3431 TRACE("transform contains stream %s\n", debugstr_w(name));
3432
3433 /* load the table */
3434 if (TABLE_CreateView( db, transform->name, (MSIVIEW**) &tv ) != ERROR_SUCCESS)
3435 continue;
3436
3437 if (tv->view.ops->execute( &tv->view, NULL ) != ERROR_SUCCESS)
3438 {
3439 tv->view.ops->delete( &tv->view );
3440 continue;
3441 }
3442
3443 tv->view.ops->delete( &tv->view );
3444 }
3445
3446 if (err_cond & MSITRANSFORM_ERROR_VIEWTRANSFORM)
3447 {
3448 static const WCHAR create_query[] = L"CREATE TABLE `_TransformView` ( "
3449 L"`Table` CHAR(0) NOT NULL TEMPORARY, `Column` CHAR(0) NOT NULL TEMPORARY, "
3450 L"`Row` CHAR(0) TEMPORARY, `Data` CHAR(0) TEMPORARY, `Current` CHAR(0) TEMPORARY "
3451 L"PRIMARY KEY `Table`, `Column`, `Row` ) HOLD";
3452
3453 MSIQUERY *query;
3454 UINT r;
3455
3456 r = MSI_DatabaseOpenViewW( db, create_query, &query );
3457 if (r != ERROR_SUCCESS)
3458 goto end;
3459
3460 r = MSI_ViewExecute( query, NULL );
3461 if (r == ERROR_SUCCESS)
3462 MSI_ViewClose( query );
3463 msiobj_release( &query->hdr );
3464 if (r != ERROR_BAD_QUERY_SYNTAX && r != ERROR_SUCCESS)
3465 goto end;
3466
3467 if (TABLE_CreateView(db, L"_TransformView", &transform_view) != ERROR_SUCCESS)
3468 goto end;
3469
3470 if (r == ERROR_BAD_QUERY_SYNTAX)
3471 transform_view->ops->add_ref( transform_view );
3472
3473 r = transform_view->ops->add_column( transform_view, L"new",
3474 MSITYPE_TEMPORARY | MSITYPE_NULLABLE | 0x402 /* INT */, FALSE );
3475 if (r != ERROR_SUCCESS)
3476 goto end;
3477 }
3478
3479 /*
3480 * Apply _Tables and _Columns transforms first so that
3481 * the table metadata is correct, and empty tables exist.
3482 */
3483 ret = table_load_transform( db, stg, strings, tables, bytes_per_strref, err_cond );
3484 if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
3485 goto end;
3486
3487 ret = table_load_transform( db, stg, strings, columns, bytes_per_strref, err_cond );
3488 if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
3489 goto end;
3490
3491 ret = ERROR_SUCCESS;
3492
3493 while ( !list_empty( &transforms ) )
3494 {
3495 transform = LIST_ENTRY( list_head( &transforms ), struct transform_data, entry );
3496
3497 if ( wcscmp( transform->name, L"_Columns" ) &&
3498 wcscmp( transform->name, L"_Tables" ) &&
3499 ret == ERROR_SUCCESS )
3500 {
3501 ret = table_load_transform( db, stg, strings, transform, bytes_per_strref, err_cond );
3502 }
3503
3504 list_remove( &transform->entry );
3505 free( transform->name );
3506 free( transform );
3507 }
3508
3509 if ( ret == ERROR_SUCCESS )
3510 {
3511 append_storage_to_db( db, stg );
3512 if (property_update) msi_clone_properties( db );
3513 }
3514
3515 end:
3516 if ( stgenum )
3517 IEnumSTATSTG_Release( stgenum );
3518 if ( strings )
3519 msi_destroy_stringtable( strings );
3520 if (transform_view)
3521 {
3522 struct tagMSITABLE *table = ((struct table_view *)transform_view)->table;
3523
3524 if (ret != ERROR_SUCCESS)
3525 transform_view->ops->release( transform_view );
3526
3527 if (!wcscmp(table->colinfo[table->col_count - 1].colname, L"new"))
3528 TABLE_remove_column( transform_view, table->colinfo[table->col_count - 1].number );
3529 transform_view->ops->delete( transform_view );
3530 }
3531
3532 return ret;
3533 }
Windows API implementation