wininet: Allow a NULL value to be passed into HTTP_ProcessHeader
[wine] / dlls / msi / table.c
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 #define NONAMELESSUNION
26 #define NONAMELESSSTRUCT
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winerror.h"
31 #include "msi.h"
32 #include "msiquery.h"
33 #include "objbase.h"
34 #include "objidl.h"
35 #include "winnls.h"
36 #include "msipriv.h"
37 #include "query.h"
38
39 #include "wine/debug.h"
40 #include "wine/unicode.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
43
44 #define MSITABLE_HASH_TABLE_SIZE 37
45
46 typedef struct tagMSICOLUMNHASHENTRY
47 {
48     struct tagMSICOLUMNHASHENTRY *next;
49     UINT value;
50     UINT row;
51 } MSICOLUMNHASHENTRY;
52
53 typedef struct tagMSICOLUMNINFO
54 {
55     LPCWSTR tablename;
56     UINT   number;
57     LPCWSTR colname;
58     UINT   type;
59     UINT   offset;
60     MSICOLUMNHASHENTRY **hash_table;
61 } MSICOLUMNINFO;
62
63 struct tagMSITABLE
64 {
65     USHORT **data;
66     UINT row_count;
67     struct list entry;
68     WCHAR name[1];
69 };
70
71 typedef struct tagMSITRANSFORM {
72     struct list entry;
73     IStorage *stg;
74 } MSITRANSFORM;
75
76 static const WCHAR szStringData[] = {
77     '_','S','t','r','i','n','g','D','a','t','a',0 };
78 static const WCHAR szStringPool[] = {
79     '_','S','t','r','i','n','g','P','o','o','l',0 };
80
81 #define MAX_STREAM_NAME 0x1f
82
83 static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name,
84        MSICOLUMNINFO **pcols, UINT *pcount );
85 static UINT get_tablecolumns( MSIDATABASE *db,
86        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz);
87 static void msi_free_colinfo( MSICOLUMNINFO *colinfo, UINT count );
88
89 static inline UINT bytes_per_column( const MSICOLUMNINFO *col )
90 {
91     if( col->type & MSITYPE_STRING )
92         return 2;
93     if( (col->type & 0xff) > 4 )
94         ERR("Invalid column size!\n");
95     return col->type & 0xff;
96 }
97
98 static int utf2mime(int x)
99 {
100     if( (x>='0') && (x<='9') )
101         return x-'0';
102     if( (x>='A') && (x<='Z') )
103         return x-'A'+10;
104     if( (x>='a') && (x<='z') )
105         return x-'a'+10+26;
106     if( x=='.' )
107         return 10+26+26;
108     if( x=='_' )
109         return 10+26+26+1;
110     return -1;
111 }
112
113 static LPWSTR encode_streamname(BOOL bTable, LPCWSTR in)
114 {
115     DWORD count = MAX_STREAM_NAME;
116     DWORD ch, next;
117     LPWSTR out, p;
118
119     if( !bTable )
120         count = lstrlenW( in )+2;
121     out = msi_alloc( count*sizeof(WCHAR) );
122     p = out;
123
124     if( bTable )
125     {
126          *p++ = 0x4840;
127          count --;
128     }
129     while( count -- ) 
130     {
131         ch = *in++;
132         if( !ch )
133         {
134             *p = ch;
135             return out;
136         }
137         if( ( ch < 0x80 ) && ( utf2mime(ch) >= 0 ) )
138         {
139             ch = utf2mime(ch) + 0x4800;
140             next = *in;
141             if( next && (next<0x80) )
142             {
143                 next = utf2mime(next);
144                 if( next >= 0  )
145                 {
146                      next += 0x3ffffc0;
147                      ch += (next<<6);
148                      in++;
149                 }
150             }
151         }
152         *p++ = ch;
153     }
154     ERR("Failed to encode stream name (%s)\n",debugstr_w(in));
155     msi_free( out );
156     return NULL;
157 }
158
159 static int mime2utf(int x)
160 {
161     if( x<10 )
162         return x + '0';
163     if( x<(10+26))
164         return x - 10 + 'A';
165     if( x<(10+26+26))
166         return x - 10 - 26 + 'a';
167     if( x == (10+26+26) )
168         return '.';
169     return '_';
170 }
171
172 static BOOL decode_streamname(LPWSTR in, LPWSTR out)
173 {
174     WCHAR ch;
175     DWORD count = 0;
176
177     while ( (ch = *in++) )
178     {
179         if( (ch >= 0x3800 ) && (ch < 0x4840 ) )
180         {
181             if( ch >= 0x4800 )
182                 ch = mime2utf(ch-0x4800);
183             else
184             {
185                 ch -= 0x3800;
186                 *out++ = mime2utf(ch&0x3f);
187                 count++;
188                 ch = mime2utf((ch>>6)&0x3f);
189             }
190         }
191         *out++ = ch;
192         count++;
193     }
194     *out = 0;
195     return count;
196 }
197
198 void enum_stream_names( IStorage *stg )
199 {
200     IEnumSTATSTG *stgenum = NULL;
201     HRESULT r;
202     STATSTG stat;
203     ULONG n, count;
204     WCHAR name[0x40];
205
206     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
207     if( FAILED( r ) )
208         return;
209
210     n = 0;
211     while( 1 )
212     {
213         count = 0;
214         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
215         if( FAILED( r ) || !count )
216             break;
217         decode_streamname( stat.pwcsName, name );
218         TRACE("stream %2d -> %s %s\n", n,
219               debugstr_w(stat.pwcsName), debugstr_w(name) );
220         n++;
221     }
222
223     IEnumSTATSTG_Release( stgenum );
224 }
225
226 static UINT read_stream_data( IStorage *stg, LPCWSTR stname,
227                               USHORT **pdata, UINT *psz )
228 {
229     HRESULT r;
230     UINT ret = ERROR_FUNCTION_FAILED;
231     VOID *data;
232     ULONG sz, count;
233     IStream *stm = NULL;
234     STATSTG stat;
235     LPWSTR encname;
236
237     encname = encode_streamname(TRUE, stname);
238
239     TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
240
241     r = IStorage_OpenStream(stg, encname, NULL, 
242             STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
243     msi_free( encname );
244     if( FAILED( r ) )
245     {
246         WARN("open stream failed r = %08x - empty table?\n", r);
247         return ret;
248     }
249
250     r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
251     if( FAILED( r ) )
252     {
253         WARN("open stream failed r = %08x!\n", r);
254         goto end;
255     }
256
257     if( stat.cbSize.QuadPart >> 32 )
258     {
259         WARN("Too big!\n");
260         goto end;
261     }
262         
263     sz = stat.cbSize.QuadPart;
264     data = msi_alloc( sz );
265     if( !data )
266     {
267         WARN("couldn't allocate memory r=%08x!\n", r);
268         ret = ERROR_NOT_ENOUGH_MEMORY;
269         goto end;
270     }
271         
272     r = IStream_Read(stm, data, sz, &count );
273     if( FAILED( r ) || ( count != sz ) )
274     {
275         msi_free( data );
276         WARN("read stream failed r = %08x!\n", r);
277         goto end;
278     }
279
280     *pdata = data;
281     *psz = sz;
282     ret = ERROR_SUCCESS;
283
284 end:
285     IStream_Release( stm );
286
287     return ret;
288 }
289
290 UINT db_get_raw_stream( MSIDATABASE *db, LPCWSTR stname, IStream **stm )
291 {
292     LPWSTR encname;
293     HRESULT r;
294
295     encname = encode_streamname(FALSE, stname);
296
297     TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
298
299     r = IStorage_OpenStream(db->storage, encname, NULL, 
300             STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm);
301     if( FAILED( r ) )
302     {
303         MSITRANSFORM *transform;
304
305         LIST_FOR_EACH_ENTRY( transform, &db->transforms, MSITRANSFORM, entry )
306         {
307             TRACE("looking for %s in transform storage\n", debugstr_w(stname) );
308             r = IStorage_OpenStream( transform->stg, encname, NULL, 
309                     STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm );
310             if (SUCCEEDED(r))
311                 break;
312         }
313     }
314
315     msi_free( encname );
316
317     return SUCCEEDED(r) ? ERROR_SUCCESS : ERROR_FUNCTION_FAILED;
318 }
319
320 UINT read_raw_stream_data( MSIDATABASE *db, LPCWSTR stname,
321                               USHORT **pdata, UINT *psz )
322 {
323     HRESULT r;
324     UINT ret = ERROR_FUNCTION_FAILED;
325     VOID *data;
326     ULONG sz, count;
327     IStream *stm = NULL;
328     STATSTG stat;
329
330     r = db_get_raw_stream( db, stname, &stm );
331     if( r != ERROR_SUCCESS)
332         return ret;
333     r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
334     if( FAILED( r ) )
335     {
336         WARN("open stream failed r = %08x!\n", r);
337         goto end;
338     }
339
340     if( stat.cbSize.QuadPart >> 32 )
341     {
342         WARN("Too big!\n");
343         goto end;
344     }
345         
346     sz = stat.cbSize.QuadPart;
347     data = msi_alloc( sz );
348     if( !data )
349     {
350         WARN("couldn't allocate memory r=%08x!\n", r);
351         ret = ERROR_NOT_ENOUGH_MEMORY;
352         goto end;
353     }
354         
355     r = IStream_Read(stm, data, sz, &count );
356     if( FAILED( r ) || ( count != sz ) )
357     {
358         msi_free( data );
359         WARN("read stream failed r = %08x!\n", r);
360         goto end;
361     }
362
363     *pdata = data;
364     *psz = sz;
365     ret = ERROR_SUCCESS;
366
367 end:
368     IStream_Release( stm );
369
370     return ret;
371 }
372
373 static UINT write_stream_data( IStorage *stg, LPCWSTR stname,
374                                LPVOID data, UINT sz )
375 {
376     HRESULT r;
377     UINT ret = ERROR_FUNCTION_FAILED;
378     ULONG count;
379     IStream *stm = NULL;
380     ULARGE_INTEGER size;
381     LARGE_INTEGER pos;
382     LPWSTR encname;
383
384     encname = encode_streamname(TRUE, stname );
385     r = IStorage_OpenStream( stg, encname, NULL, 
386             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
387     if( FAILED(r) )
388     {
389         r = IStorage_CreateStream( stg, encname,
390                 STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
391     }
392     msi_free( encname );
393     if( FAILED( r ) )
394     {
395         WARN("open stream failed r = %08x\n", r);
396         return ret;
397     }
398
399     size.QuadPart = sz;
400     r = IStream_SetSize( stm, size );
401     if( FAILED( r ) )
402     {
403         WARN("Failed to SetSize\n");
404         goto end;
405     }
406
407     pos.QuadPart = 0;
408     r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
409     if( FAILED( r ) )
410     {
411         WARN("Failed to Seek\n");
412         goto end;
413     }
414
415     r = IStream_Write(stm, data, sz, &count );
416     if( FAILED( r ) || ( count != sz ) )
417     {
418         WARN("Failed to Write\n");
419         goto end;
420     }
421
422     ret = ERROR_SUCCESS;
423
424 end:
425     IStream_Release( stm );
426
427     return ret;
428 }
429
430 static void free_table( MSITABLE *table )
431 {
432     int i;
433     for( i=0; i<table->row_count; i++ )
434         msi_free( table->data[i] );
435     msi_free( table->data );
436     msi_free( table );
437 }
438
439 static UINT msi_table_get_row_size( const MSICOLUMNINFO *cols, UINT count )
440 {
441     const MSICOLUMNINFO *last_col = &cols[count-1];
442     if (!count)
443         return 0;
444     return last_col->offset + bytes_per_column( last_col );
445 }
446
447 /* add this table to the list of cached tables in the database */
448 static MSITABLE *read_table_from_storage( IStorage *stg, LPCWSTR name,
449                                     const MSICOLUMNINFO *cols, UINT num_cols )
450 {
451     MSITABLE *t;
452     USHORT *rawdata = NULL;
453     UINT rawsize = 0, i, j, row_size = 0;
454
455     TRACE("%s\n",debugstr_w(name));
456
457     /* nonexistent tables should be interpreted as empty tables */
458     t = msi_alloc( sizeof (MSITABLE) + lstrlenW(name)*sizeof (WCHAR) );
459     if( !t )
460         return t;
461
462     row_size = msi_table_get_row_size( cols, num_cols );
463
464     t->row_count = 0;
465     t->data = NULL;
466     lstrcpyW( t->name, name );
467
468     /* if we can't read the table, just assume that it's empty */
469     read_stream_data( stg, name, &rawdata, &rawsize );
470     if( !rawdata )
471         return t;
472
473     TRACE("Read %d bytes\n", rawsize );
474
475     if( rawsize % row_size )
476     {
477         WARN("Table size is invalid %d/%d\n", rawsize, row_size );
478         goto err;
479     }
480
481     t->row_count = rawsize / row_size;
482     t->data = msi_alloc_zero( t->row_count * sizeof (USHORT*) );
483     if( !t->data )
484         goto err;
485
486     /* transpose all the data */
487     TRACE("Transposing data from %d rows\n", t->row_count );
488     for( i=0; i<t->row_count; i++ )
489     {
490         t->data[i] = msi_alloc( row_size );
491         if( !t->data[i] )
492             goto err;
493
494         for( j=0; j<num_cols; j++ )
495         {
496             UINT ofs = cols[j].offset/2;
497             UINT n = bytes_per_column( &cols[j] );
498
499             switch( n )
500             {
501             case 2:
502                 t->data[i][ofs] = rawdata[ofs*t->row_count + i ];
503                 break;
504             case 4:
505                 t->data[i][ofs] = rawdata[ofs*t->row_count + i*2 ];
506                 t->data[i][ofs+1] = rawdata[ofs*t->row_count + i*2 + 1];
507                 break;
508             default:
509                 ERR("oops - unknown column width %d\n", n);
510                 goto err;
511             }
512         }
513     }
514
515     msi_free( rawdata );
516     return t;
517 err:
518     msi_free( rawdata );
519     free_table( t );
520     return NULL;
521 }
522
523 void free_cached_tables( MSIDATABASE *db )
524 {
525     while( !list_empty( &db->tables ) )
526     {
527         MSITABLE *t = LIST_ENTRY( list_head( &db->tables ), MSITABLE, entry );
528
529         list_remove( &t->entry );
530         free_table( t );
531     }
532 }
533
534 static MSITABLE *find_cached_table( MSIDATABASE *db, LPCWSTR name )
535 {
536     MSITABLE *t;
537
538     LIST_FOR_EACH_ENTRY( t, &db->tables, MSITABLE, entry )
539         if( !lstrcmpW( name, t->name ) )
540             return t;
541
542     return NULL;
543 }
544
545 static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name, MSICOLUMNINFO **pcols, UINT *pcount )
546 {
547     UINT r, column_count = 0;
548     MSICOLUMNINFO *columns;
549
550     /* get the number of columns in this table */
551     column_count = 0;
552     r = get_tablecolumns( db, name, NULL, &column_count );
553     if( r != ERROR_SUCCESS )
554         return r;
555
556     /* if there's no columns, there's no table */
557     if( column_count == 0 )
558         return ERROR_INVALID_PARAMETER;
559
560     TRACE("Table %s found\n", debugstr_w(name) );
561
562     columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO) );
563     if( !columns )
564         return ERROR_FUNCTION_FAILED;
565
566     r = get_tablecolumns( db, name, columns, &column_count );
567     if( r != ERROR_SUCCESS )
568     {
569         msi_free( columns );
570         return ERROR_FUNCTION_FAILED;
571     }
572
573     *pcols = columns;
574     *pcount = column_count;
575
576     return r;
577 }
578
579 static MSITABLE *get_table( MSIDATABASE *db, LPCWSTR name,
580                             const MSICOLUMNINFO *cols, UINT num_cols )
581 {
582     MSITABLE *table;
583
584     /* first, see if the table is cached */
585     table = find_cached_table( db, name );
586     if( table )
587         return table;
588
589     table = read_table_from_storage( db->storage, name, cols, num_cols );
590     if( table )
591         list_add_head( &db->tables, &table->entry );
592
593     return table;
594 }
595
596 static UINT save_table( MSIDATABASE *db, MSITABLE *t )
597 {
598     USHORT *rawdata = NULL, *p;
599     UINT rawsize, r, i, j, row_size, num_cols = 0;
600     MSICOLUMNINFO *cols = NULL;
601
602     TRACE("Saving %s\n", debugstr_w( t->name ) );
603
604     r = table_get_column_info( db, t->name, &cols, &num_cols );
605     if( r != ERROR_SUCCESS )
606         return r;
607     
608     row_size = msi_table_get_row_size( cols, num_cols );
609
610     rawsize = t->row_count * row_size;
611     rawdata = msi_alloc_zero( rawsize );
612     if( !rawdata )
613     {
614         r = ERROR_NOT_ENOUGH_MEMORY;
615         goto err;
616     }
617
618     p = rawdata;
619     for( i=0; i<num_cols; i++ )
620     {
621         for( j=0; j<t->row_count; j++ )
622         {
623             UINT offset = cols[i].offset;
624
625             *p++ = t->data[j][offset/2];
626             if( 4 == bytes_per_column( &cols[i] ) )
627                 *p++ = t->data[j][offset/2+1];
628         }
629     }
630
631     TRACE("writing %d bytes\n", rawsize);
632     r = write_stream_data( db->storage, t->name, rawdata, rawsize );
633
634 err:
635     msi_free_colinfo( cols, num_cols );
636     msi_free( cols );
637     msi_free( rawdata );
638
639     return r;
640 }
641
642 HRESULT init_string_table( IStorage *stg )
643 {
644     HRESULT r;
645     USHORT zero[2] = { 0, 0 };
646     ULONG count = 0;
647     IStream *stm = NULL;
648     LPWSTR encname;
649
650     encname = encode_streamname(TRUE, szStringPool );
651
652     /* create the StringPool stream... add the zero string to it*/
653     r = IStorage_CreateStream( stg, encname,
654             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
655     msi_free( encname );
656     if( r ) 
657     {
658         TRACE("Failed\n");
659         return r;
660     }
661
662     r = IStream_Write(stm, zero, sizeof zero, &count );
663     IStream_Release( stm );
664
665     if( FAILED( r ) || ( count != sizeof zero ) )
666     {
667         TRACE("Failed\n");
668         return E_FAIL;
669     }
670
671     /* create the StringData stream... make it zero length */
672     encname = encode_streamname(TRUE, szStringData );
673     r = IStorage_CreateStream( stg, encname,
674             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
675     msi_free( encname );
676     if( r ) 
677     {
678         TRACE("Failed\n");
679         return E_FAIL;
680     }
681     IStream_Release( stm );
682
683     return r;
684 }
685
686 string_table *load_string_table( IStorage *stg )
687 {
688     string_table *st = NULL;
689     CHAR *data = NULL;
690     USHORT *pool = NULL;
691     UINT r, datasize = 0, poolsize = 0, codepage;
692     DWORD i, count, offset, len, n, refs;
693
694     r = read_stream_data( stg, szStringPool, &pool, &poolsize );
695     if( r != ERROR_SUCCESS)
696         goto end;
697     r = read_stream_data( stg, szStringData, (USHORT**)&data, &datasize );
698     if( r != ERROR_SUCCESS)
699         goto end;
700
701     count = poolsize/4;
702     if( poolsize > 4 )
703         codepage = pool[0] | ( pool[1] << 16 );
704     else
705         codepage = CP_ACP;
706     st = msi_init_stringtable( count, codepage );
707
708     offset = 0;
709     n = 1;
710     i = 1;
711     while( i<count )
712     {
713         /* the string reference count is always the second word */
714         refs = pool[i*2+1];
715
716         /* empty entries have two zeros, still have a string id */
717         if (pool[i*2] == 0 && refs == 0)
718         {
719             i++;
720             n++;
721             continue;
722         }
723
724         /*
725          * If a string is over 64k, the previous string entry is made null
726          * and its the high word of the length is inserted in the null string's
727          * reference count field.
728          */
729         if( pool[i*2] == 0)
730         {
731             len = (pool[i*2+3] << 16) + pool[i*2+2];
732             i += 2;
733         }
734         else
735         {
736             len = pool[i*2];
737             i += 1;
738         }
739
740         if ( (offset + len) > datasize )
741         {
742             ERR("string table corrupt?\n");
743             break;
744         }
745
746         r = msi_addstring( st, n, data+offset, len, refs );
747         if( r != n )
748             ERR("Failed to add string %d\n", n );
749         n++;
750         offset += len;
751     }
752
753     if ( datasize != offset )
754         ERR("string table load failed! (%08x != %08x), please report\n", datasize, offset );
755
756     TRACE("Loaded %d strings\n", count);
757
758 end:
759     msi_free( pool );
760     msi_free( data );
761
762     return st;
763 }
764
765 static UINT save_string_table( MSIDATABASE *db )
766 {
767     UINT i, count, datasize = 0, poolsize = 0, sz, used, r, codepage, n;
768     UINT ret = ERROR_FUNCTION_FAILED;
769     CHAR *data = NULL;
770     USHORT *pool = NULL;
771
772     TRACE("\n");
773
774     /* construct the new table in memory first */
775     count = msi_string_totalsize( db->strings, &datasize, &poolsize );
776
777     TRACE("%u %u %u\n", count, datasize, poolsize );
778
779     pool = msi_alloc( poolsize );
780     if( ! pool )
781     {
782         WARN("Failed to alloc pool %d bytes\n", poolsize );
783         goto err;
784     }
785     data = msi_alloc( datasize );
786     if( ! data )
787     {
788         WARN("Failed to alloc data %d bytes\n", poolsize );
789         goto err;
790     }
791
792     used = 0;
793     codepage = msi_string_get_codepage( db->strings );
794     pool[0]=codepage&0xffff;
795     pool[1]=(codepage>>16);
796     n = 1;
797     for( i=1; i<count; i++ )
798     {
799         sz = datasize - used;
800         r = msi_id2stringA( db->strings, i, data+used, &sz );
801         if( r != ERROR_SUCCESS )
802         {
803             ERR("failed to fetch string\n");
804             sz = 0;
805         }
806         if( sz && (sz < (datasize - used ) ) )
807             sz--;
808
809         if (sz)
810             pool[ n*2 + 1 ] = msi_id_refcount( db->strings, i );
811         else
812             pool[ n*2 + 1 ] = 0;
813         if (sz < 0x10000)
814         {
815             pool[ n*2 ] = sz;
816             n++;
817         }
818         else
819         {
820             pool[ n*2 ] = 0;
821             pool[ n*2 + 2 ] = sz&0xffff;
822             pool[ n*2 + 3 ] = (sz>>16);
823             n += 2;
824         }
825         used += sz;
826         if( used > datasize  )
827         {
828             ERR("oops overran %d >= %d\n", used, datasize);
829             goto err;
830         }
831     }
832
833     if( used != datasize )
834     {
835         ERR("oops used %d != datasize %d\n", used, datasize);
836         goto err;
837     }
838
839     /* write the streams */
840     r = write_stream_data( db->storage, szStringData, data, datasize );
841     TRACE("Wrote StringData r=%08x\n", r);
842     if( r )
843         goto err;
844     r = write_stream_data( db->storage, szStringPool, pool, poolsize );
845     TRACE("Wrote StringPool r=%08x\n", r);
846     if( r )
847         goto err;
848
849     ret = ERROR_SUCCESS;
850
851 err:
852     msi_free( data );
853     msi_free( pool );
854
855     return ret;
856 }
857
858 /* information for default tables */
859 static const WCHAR szTables[]  = { '_','T','a','b','l','e','s',0 };
860 static const WCHAR szTable[]  = { 'T','a','b','l','e',0 };
861 static const WCHAR szName[]    = { 'N','a','m','e',0 };
862 static const WCHAR szColumns[] = { '_','C','o','l','u','m','n','s',0 };
863 static const WCHAR szNumber[]  = { 'N','u','m','b','e','r',0 };
864 static const WCHAR szType[]    = { 'T','y','p','e',0 };
865
866 static const MSICOLUMNINFO _Columns_cols[4] = {
867     { szColumns, 1, szTable,  MSITYPE_VALID | MSITYPE_STRING | 64, 0 },
868     { szColumns, 2, szNumber, MSITYPE_VALID | 2,                   2 },
869     { szColumns, 3, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 4 },
870     { szColumns, 4, szType,   MSITYPE_VALID | 2,                   6 },
871 };
872 static const MSICOLUMNINFO _Tables_cols[1] = {
873     { szTables,  1, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 0 },
874 };
875
876 static UINT get_defaulttablecolumns( LPCWSTR name, MSICOLUMNINFO *colinfo, UINT *sz)
877 {
878     const MSICOLUMNINFO *p;
879     DWORD i, n;
880
881     TRACE("%s\n", debugstr_w(name));
882
883     if (!lstrcmpW( name, szTables ))
884     {
885         p = _Tables_cols;
886         n = 1;
887     }
888     else if (!lstrcmpW( name, szColumns ))
889     {
890         p = _Columns_cols;
891         n = 4;
892     }
893     else
894         return ERROR_FUNCTION_FAILED;
895
896     /* duplicate the string data so we can free it in msi_free_colinfo */
897     for (i=0; i<n; i++)
898     {
899         if (colinfo && (i < *sz) )
900         {
901             memcpy( &colinfo[i], &p[i], sizeof(MSICOLUMNINFO) );
902             colinfo[i].tablename = strdupW( p[i].tablename );
903             colinfo[i].colname = strdupW( p[i].colname );
904         }
905         if( colinfo && (i >= *sz) )
906             break;
907     }
908     *sz = n;
909     return ERROR_SUCCESS;
910 }
911
912 static void msi_free_colinfo( MSICOLUMNINFO *colinfo, UINT count )
913 {
914     UINT i;
915
916     for( i=0; i<count; i++ )
917     {
918         msi_free( (LPWSTR) colinfo[i].tablename );
919         msi_free( (LPWSTR) colinfo[i].colname );
920         msi_free( colinfo[i].hash_table );
921     }
922 }
923
924 static LPWSTR msi_makestring( MSIDATABASE *db, UINT stringid)
925 {
926     return strdupW(msi_string_lookup_id( db->strings, stringid ));
927 }
928
929 static UINT get_tablecolumns( MSIDATABASE *db,
930        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz)
931 {
932     UINT r, i, n=0, table_id, count, maxcount = *sz;
933     MSITABLE *table = NULL;
934
935     TRACE("%s\n", debugstr_w(szTableName));
936
937     /* first check if there is a default table with that name */
938     r = get_defaulttablecolumns( szTableName, colinfo, sz );
939     if( ( r == ERROR_SUCCESS ) && *sz )
940         return r;
941
942     table = get_table( db, szColumns, _Columns_cols, 4 );
943     if( !table )
944     {
945         ERR("couldn't load _Columns table\n");
946         return ERROR_FUNCTION_FAILED;
947     }
948
949     /* convert table and column names to IDs from the string table */
950     r = msi_string2idW( db->strings, szTableName, &table_id );
951     if( r != ERROR_SUCCESS )
952     {
953         WARN("Couldn't find id for %s\n", debugstr_w(szTableName));
954         return r;
955     }
956
957     TRACE("Table id is %d, row count is %d\n", table_id, table->row_count);
958
959     /* if maxcount is non-zero, assume it's exactly right for this table */
960     memset( colinfo, 0, maxcount*sizeof(*colinfo) );
961     count = table->row_count;
962     for( i=0; i<count; i++ )
963     {
964         if( table->data[ i ][ 0 ] != table_id )
965             continue;
966         if( colinfo )
967         {
968             UINT id = table->data[ i ] [ 2 ];
969             UINT col = table->data[ i ][ 1 ] - (1<<15);
970
971             /* check the column number is in range */
972             if (col<1 || col>maxcount)
973             {
974                 ERR("column %d out of range\n", col);
975                 continue;
976             }
977
978             /* check if this column was already set */
979             if (colinfo[ col - 1 ].number)
980             {
981                 ERR("duplicate column %d\n", col);
982                 continue;
983             }
984
985             colinfo[ col - 1 ].tablename = msi_makestring( db, table_id );
986             colinfo[ col - 1 ].number = col;
987             colinfo[ col - 1 ].colname = msi_makestring( db, id );
988             colinfo[ col - 1 ].type = table->data[ i ] [ 3 ] - (1<<15);
989             colinfo[ col - 1 ].offset = 0;
990             colinfo[ col - 1 ].hash_table = NULL;
991         }
992         n++;
993     }
994
995     TRACE("%s has %d columns\n", debugstr_w(szTableName), n);
996
997     if (maxcount && n != maxcount)
998     {
999         ERR("missing column in table %s\n", debugstr_w(szTableName));
1000         msi_free_colinfo(colinfo, maxcount );
1001         return ERROR_FUNCTION_FAILED;
1002     }
1003
1004     /* calculate the offsets */
1005     for( i=0; maxcount && (i<maxcount); i++ )
1006     {
1007          assert( (i+1) == colinfo[ i ].number );
1008          if (i)
1009              colinfo[i].offset = colinfo[ i - 1 ].offset
1010                                + bytes_per_column( &colinfo[ i - 1 ] );
1011          else
1012              colinfo[i].offset = 0;
1013          TRACE("column %d is [%s] with type %08x ofs %d\n",
1014                colinfo[i].number, debugstr_w(colinfo[i].colname),
1015                colinfo[i].type, colinfo[i].offset);
1016     }
1017     *sz = n;
1018
1019     return ERROR_SUCCESS;
1020 }
1021
1022 /* try to find the table name in the _Tables table */
1023 BOOL TABLE_Exists( MSIDATABASE *db, LPWSTR name )
1024 {
1025     UINT r, table_id = 0, i, count;
1026     MSITABLE *table = NULL;
1027
1028     if( !lstrcmpW( name, szTables ) )
1029         return TRUE;
1030     if( !lstrcmpW( name, szColumns ) )
1031         return TRUE;
1032
1033     r = msi_string2idW( db->strings, name, &table_id );
1034     if( r != ERROR_SUCCESS )
1035     {
1036         TRACE("Couldn't find id for %s\n", debugstr_w(name));
1037         return FALSE;
1038     }
1039
1040     table = get_table( db, szTables, _Tables_cols, 1 );
1041     if( !table )
1042     {
1043         TRACE("table %s not available\n", debugstr_w(szTables));
1044         return FALSE;
1045     }
1046
1047     /* count = table->size/2; */
1048     count = table->row_count;
1049     for( i=0; i<count; i++ )
1050         if( table->data[ i ][ 0 ] == table_id )
1051             break;
1052
1053     if (i!=count)
1054         return TRUE;
1055
1056     TRACE("Searched %d tables, but %d was not found\n", count, table_id );
1057
1058     return FALSE;
1059 }
1060
1061 /* below is the query interface to a table */
1062
1063 typedef struct tagMSITABLEVIEW
1064 {
1065     MSIVIEW        view;
1066     MSIDATABASE   *db;
1067     MSITABLE      *table;
1068     MSICOLUMNINFO *columns;
1069     UINT           num_cols;
1070     UINT           row_size;
1071     WCHAR          name[1];
1072 } MSITABLEVIEW;
1073
1074 static UINT TABLE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
1075 {
1076     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1077     UINT offset, num_rows, n;
1078
1079     if( !tv->table )
1080         return ERROR_INVALID_PARAMETER;
1081
1082     if( (col==0) || (col>tv->num_cols) )
1083         return ERROR_INVALID_PARAMETER;
1084
1085     /* how many rows are there ? */
1086     num_rows = tv->table->row_count;
1087     if( row >= num_rows )
1088         return ERROR_NO_MORE_ITEMS;
1089
1090     if( tv->columns[col-1].offset >= tv->row_size )
1091     {
1092         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1093         ERR("%p %p\n", tv, tv->columns );
1094         return ERROR_FUNCTION_FAILED;
1095     }
1096
1097     offset = row + (tv->columns[col-1].offset/2) * num_rows;
1098     n = bytes_per_column( &tv->columns[col-1] );
1099     switch( n )
1100     {
1101     case 4:
1102         offset = tv->columns[col-1].offset/2;
1103         *val = tv->table->data[row][offset] +
1104                (tv->table->data[row][offset + 1] << 16);
1105         break;
1106     case 2:
1107         offset = tv->columns[col-1].offset/2;
1108         *val = tv->table->data[row][offset];
1109         break;
1110     default:
1111         ERR("oops! what is %d bytes per column?\n", n );
1112         return ERROR_FUNCTION_FAILED;
1113     }
1114
1115     /* TRACE("Data [%d][%d] = %d\n", row, col, *val ); */
1116
1117     return ERROR_SUCCESS;
1118 }
1119
1120 /*
1121  * We need a special case for streams, as we need to reference column with
1122  * the name of the stream in the same table, and the table name
1123  * which may not be available at higher levels of the query
1124  */
1125 static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
1126 {
1127     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1128     UINT ival = 0, refcol = 0, r;
1129     LPCWSTR sval;
1130     LPWSTR full_name;
1131     DWORD len;
1132     static const WCHAR szDot[] = { '.', 0 };
1133     WCHAR number[0x20];
1134
1135     if( !view->ops->fetch_int )
1136         return ERROR_INVALID_PARAMETER;
1137
1138     /*
1139      * The column marked with the type stream data seems to have a single number
1140      * which references the column containing the name of the stream data
1141      *
1142      * Fetch the column to reference first.
1143      */
1144     r = view->ops->fetch_int( view, row, col, &ival );
1145     if( r != ERROR_SUCCESS )
1146         return r;
1147
1148     /* check the column value is in range */
1149     if (ival < 0 || ival > tv->num_cols || ival == col)
1150     {
1151         ERR("bad column ref (%u) for stream\n", ival);
1152         return ERROR_FUNCTION_FAILED;
1153     }
1154
1155     if ( tv->columns[ival - 1].type & MSITYPE_STRING )
1156     {
1157         /* now get the column with the name of the stream */
1158         r = view->ops->fetch_int( view, row, ival, &refcol );
1159         if ( r != ERROR_SUCCESS )
1160             return r;
1161
1162         /* lookup the string value from the string table */
1163         sval = msi_string_lookup_id( tv->db->strings, refcol );
1164         if ( !sval )
1165             return ERROR_INVALID_PARAMETER;
1166     }
1167     else
1168     {
1169         static const WCHAR fmt[] = { '%','d',0 };
1170         sprintfW( number, fmt, ival );
1171         sval = number;
1172     }
1173
1174     len = lstrlenW( tv->name ) + 2 + lstrlenW( sval );
1175     full_name = msi_alloc( len*sizeof(WCHAR) );
1176     lstrcpyW( full_name, tv->name );
1177     lstrcatW( full_name, szDot );
1178     lstrcatW( full_name, sval );
1179
1180     r = db_get_raw_stream( tv->db, full_name, stm );
1181     if( r )
1182         ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r);
1183     msi_free( full_name );
1184
1185     return r;
1186 }
1187
1188 static UINT TABLE_set_int( MSITABLEVIEW *tv, UINT row, UINT col, UINT val )
1189 {
1190     UINT offset, n;
1191
1192     if( !tv->table )
1193         return ERROR_INVALID_PARAMETER;
1194
1195     if( (col==0) || (col>tv->num_cols) )
1196         return ERROR_INVALID_PARAMETER;
1197
1198     if( tv->columns[col-1].offset >= tv->row_size )
1199     {
1200         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1201         ERR("%p %p\n", tv, tv->columns );
1202         return ERROR_FUNCTION_FAILED;
1203     }
1204
1205     n = bytes_per_column( &tv->columns[col-1] );
1206     switch( n )
1207     {
1208     case 4:
1209         offset = tv->columns[col-1].offset/2;
1210         tv->table->data[row][offset]     = val & 0xffff;
1211         tv->table->data[row][offset + 1] = (val>>16)&0xffff;
1212         break;
1213     case 2:
1214         offset = tv->columns[col-1].offset/2;
1215         tv->table->data[row][offset] = val;
1216         break;
1217     default:
1218         ERR("oops! what is %d bytes per column?\n", n );
1219         return ERROR_FUNCTION_FAILED;
1220     }
1221     return ERROR_SUCCESS;
1222 }
1223
1224 static UINT TABLE_set_row( struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask )
1225 {
1226     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1227     UINT i, val, r = ERROR_SUCCESS;
1228
1229     if ( !tv->table )
1230         return ERROR_INVALID_PARAMETER;
1231
1232     /* test if any of the mask bits are invalid */
1233     if ( mask >= (1<<tv->num_cols) )
1234         return ERROR_INVALID_PARAMETER;
1235
1236     for ( i = 0; i < tv->num_cols; i++ )
1237     {
1238         /* only update the fields specified in the mask */
1239         if ( !(mask&(1<<i)) )
1240             continue;
1241
1242         /* FIXME: should we allow updating keys? */
1243
1244         val = 0;
1245         if ( !MSI_RecordIsNull( rec, i + 1 ) )
1246         {
1247             if ( MSITYPE_IS_BINARY(tv->columns[ i ].type) )
1248             {
1249                 val = 1; /* refers to the first key column */
1250             }
1251             else if ( tv->columns[i].type & MSITYPE_STRING )
1252             {
1253                 LPCWSTR sval = MSI_RecordGetString( rec, i + 1 );
1254                 val = msi_addstringW( tv->db->strings, 0, sval, -1, 1 );
1255             }
1256             else if ( 2 == bytes_per_column( &tv->columns[ i ] ) )
1257             {
1258                 val = 0x8000 + MSI_RecordGetInteger( rec, i + 1 );
1259                 if ( val & 0xffff0000 )
1260                 {
1261                     ERR("field %u value %d out of range\n", i+1, val - 0x8000 );
1262                     return ERROR_FUNCTION_FAILED;
1263                 }
1264             }
1265             else
1266             {
1267                 INT ival = MSI_RecordGetInteger( rec, i + 1 );
1268                 val = ival ^ 0x80000000;
1269             }
1270         }
1271
1272         r = TABLE_set_int( tv, row, i+1, val );
1273         if ( r != ERROR_SUCCESS )
1274             break;
1275     }
1276     return r;
1277 }
1278
1279 static UINT table_create_new_row( struct tagMSIVIEW *view, UINT *num )
1280 {
1281     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1282     USHORT **p, *row;
1283     UINT sz;
1284
1285     TRACE("%p\n", view);
1286
1287     if( !tv->table )
1288         return ERROR_INVALID_PARAMETER;
1289
1290     row = msi_alloc_zero( tv->row_size );
1291     if( !row )
1292         return ERROR_NOT_ENOUGH_MEMORY;
1293
1294     sz = (tv->table->row_count + 1) * sizeof (UINT*);
1295     if( tv->table->data )
1296         p = msi_realloc( tv->table->data, sz );
1297     else
1298         p = msi_alloc( sz );
1299     if( !p )
1300     {
1301         msi_free( row );
1302         return ERROR_NOT_ENOUGH_MEMORY;
1303     }
1304
1305     tv->table->data = p;
1306     tv->table->data[tv->table->row_count] = row;
1307     *num = tv->table->row_count;
1308     tv->table->row_count++;
1309
1310     return ERROR_SUCCESS;
1311 }
1312
1313 static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
1314 {
1315     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1316
1317     TRACE("%p %p\n", tv, record);
1318
1319     TRACE("There are %d columns\n", tv->num_cols );
1320     tv->table = get_table( tv->db, tv->name, tv->columns, tv->num_cols );
1321     if( !tv->table )
1322         return ERROR_FUNCTION_FAILED;
1323
1324     return ERROR_SUCCESS;
1325 }
1326
1327 static UINT TABLE_close( struct tagMSIVIEW *view )
1328 {
1329     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1330
1331     TRACE("%p\n", view );
1332
1333     if( !tv->table )
1334         return ERROR_FUNCTION_FAILED;
1335
1336     tv->table = NULL;
1337     
1338     return ERROR_SUCCESS;
1339 }
1340
1341 static UINT TABLE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols)
1342 {
1343     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1344
1345     TRACE("%p %p %p\n", view, rows, cols );
1346
1347     if( cols )
1348         *cols = tv->num_cols;
1349     if( rows )
1350     {
1351         if( !tv->table )
1352             return ERROR_INVALID_PARAMETER;
1353         *rows = tv->table->row_count;
1354     }
1355
1356     return ERROR_SUCCESS;
1357 }
1358
1359 static UINT TABLE_get_column_info( struct tagMSIVIEW *view,
1360                 UINT n, LPWSTR *name, UINT *type )
1361 {
1362     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1363
1364     TRACE("%p %d %p %p\n", tv, n, name, type );
1365
1366     if( ( n == 0 ) || ( n > tv->num_cols ) )
1367         return ERROR_INVALID_PARAMETER;
1368
1369     if( name )
1370     {
1371         *name = strdupW( tv->columns[n-1].colname );
1372         if( !*name )
1373             return ERROR_FUNCTION_FAILED;
1374     }
1375     if( type )
1376         *type = tv->columns[n-1].type;
1377
1378     return ERROR_SUCCESS;
1379 }
1380
1381 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row );
1382
1383 static UINT table_validate_new( MSITABLEVIEW *tv, MSIRECORD *rec )
1384 {
1385     UINT r, row, i;
1386
1387     /* check there's no null values where they're not allowed */
1388     for( i = 0; i < tv->num_cols; i++ )
1389     {
1390         if ( tv->columns[i].type & MSITYPE_NULLABLE )
1391             continue;
1392
1393         if ( MSITYPE_IS_BINARY(tv->columns[i].type) )
1394             TRACE("skipping binary column\n");
1395         else if ( tv->columns[i].type & MSITYPE_STRING )
1396         {
1397             LPCWSTR str;
1398
1399             str = MSI_RecordGetString( rec, i+1 );
1400             if (str == NULL || str[0] == 0)
1401                 return ERROR_INVALID_DATA;
1402         }
1403         else
1404         {
1405             UINT n;
1406
1407             n = MSI_RecordGetInteger( rec, i+1 );
1408             if (n == MSI_NULL_INTEGER)
1409                 return ERROR_INVALID_DATA;
1410         }
1411     }
1412
1413     /* check there's no duplicate keys */
1414     r = msi_table_find_row( tv, rec, &row );
1415     if (r == ERROR_SUCCESS)
1416         return ERROR_INVALID_DATA;
1417
1418     return ERROR_SUCCESS;
1419 }
1420
1421 static UINT TABLE_insert_row( struct tagMSIVIEW *view, MSIRECORD *rec )
1422 {
1423     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1424     UINT r, row = -1;
1425
1426     TRACE("%p %p\n", tv, rec );
1427
1428     /* check that the key is unique - can we find a matching row? */
1429     r = table_validate_new( tv, rec );
1430     if( r != ERROR_SUCCESS )
1431         return ERROR_FUNCTION_FAILED;
1432
1433     r = table_create_new_row( view, &row );
1434     TRACE("insert_row returned %08x\n", r);
1435     if( r != ERROR_SUCCESS )
1436         return r;
1437
1438     return TABLE_set_row( view, row, rec, (1<<tv->num_cols) - 1 );
1439 }
1440
1441 static UINT TABLE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
1442                 MSIRECORD *rec)
1443 {
1444     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1445     UINT r;
1446
1447     TRACE("%p %d %p\n", view, eModifyMode, rec );
1448
1449     if (!tv->table)
1450     {
1451         r = TABLE_execute( view, NULL );
1452         if( r )
1453             return r;
1454     }
1455
1456     switch (eModifyMode)
1457     {
1458     case MSIMODIFY_VALIDATE_NEW:
1459         r = table_validate_new( tv, rec );
1460         break;
1461
1462     case MSIMODIFY_INSERT_TEMPORARY:
1463         r = table_validate_new( tv, rec );
1464         if (r != ERROR_SUCCESS)
1465             break;
1466         r = TABLE_insert_row( view, rec );
1467         break;
1468
1469     case MSIMODIFY_REFRESH:
1470     case MSIMODIFY_INSERT:
1471     case MSIMODIFY_UPDATE:
1472     case MSIMODIFY_ASSIGN:
1473     case MSIMODIFY_REPLACE:
1474     case MSIMODIFY_MERGE:
1475     case MSIMODIFY_DELETE:
1476     case MSIMODIFY_VALIDATE:
1477     case MSIMODIFY_VALIDATE_FIELD:
1478     case MSIMODIFY_VALIDATE_DELETE:
1479         FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
1480         r = ERROR_CALL_NOT_IMPLEMENTED;
1481         break;
1482
1483     default:
1484         r = ERROR_INVALID_DATA;
1485     }
1486
1487     return r;
1488 }
1489
1490 static UINT TABLE_delete( struct tagMSIVIEW *view )
1491 {
1492     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1493
1494     TRACE("%p\n", view );
1495
1496     tv->table = NULL;
1497
1498     if( tv->columns )
1499     {
1500         msi_free_colinfo( tv->columns, tv->num_cols );
1501         msi_free( tv->columns );
1502     }
1503     tv->columns = NULL;
1504
1505     msi_free( tv );
1506
1507     return ERROR_SUCCESS;
1508 }
1509
1510 static UINT TABLE_find_matching_rows( struct tagMSIVIEW *view, UINT col,
1511     UINT val, UINT *row, MSIITERHANDLE *handle )
1512 {
1513     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1514     const MSICOLUMNHASHENTRY *entry;
1515
1516     TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
1517
1518     if( !tv->table )
1519         return ERROR_INVALID_PARAMETER;
1520
1521     if( (col==0) || (col > tv->num_cols) )
1522         return ERROR_INVALID_PARAMETER;
1523
1524     if( !tv->columns[col-1].hash_table )
1525     {
1526         UINT i;
1527         UINT num_rows = tv->table->row_count;
1528         MSICOLUMNHASHENTRY **hash_table;
1529         MSICOLUMNHASHENTRY *new_entry;
1530
1531         if( tv->columns[col-1].offset >= tv->row_size )
1532         {
1533             ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1534             ERR("%p %p\n", tv, tv->columns );
1535             return ERROR_FUNCTION_FAILED;
1536         }
1537
1538         /* allocate contiguous memory for the table and its entries so we
1539          * don't have to do an expensive cleanup */
1540         hash_table = msi_alloc(MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*) +
1541             num_rows * sizeof(MSICOLUMNHASHENTRY));
1542         if (!hash_table)
1543             return ERROR_OUTOFMEMORY;
1544
1545         memset(hash_table, 0, MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*));
1546         tv->columns[col-1].hash_table = hash_table;
1547
1548         new_entry = (MSICOLUMNHASHENTRY *)(hash_table + MSITABLE_HASH_TABLE_SIZE);
1549
1550         for (i = 0; i < num_rows; i++, new_entry++)
1551         {
1552             UINT row_value, n;
1553             UINT offset = i + (tv->columns[col-1].offset/2) * num_rows;
1554             n = bytes_per_column( &tv->columns[col-1] );
1555             switch( n )
1556             {
1557             case 4:
1558                 offset = tv->columns[col-1].offset/2;
1559                 row_value = tv->table->data[i][offset] + 
1560                     (tv->table->data[i][offset + 1] << 16);
1561                 break;
1562             case 2:
1563                 offset = tv->columns[col-1].offset/2;
1564                 row_value = tv->table->data[i][offset];
1565                 break;
1566             default:
1567                 ERR("oops! what is %d bytes per column?\n", n );
1568                 continue;
1569             }
1570
1571             new_entry->next = NULL;
1572             new_entry->value = row_value;
1573             new_entry->row = i;
1574             if (hash_table[row_value % MSITABLE_HASH_TABLE_SIZE])
1575             {
1576                 MSICOLUMNHASHENTRY *prev_entry = hash_table[row_value % MSITABLE_HASH_TABLE_SIZE];
1577                 while (prev_entry->next)
1578                     prev_entry = prev_entry->next;
1579                 prev_entry->next = new_entry;
1580             }
1581             else
1582                 hash_table[row_value % MSITABLE_HASH_TABLE_SIZE] = new_entry;
1583         }
1584     }
1585
1586     if( !*handle )
1587         entry = tv->columns[col-1].hash_table[val % MSITABLE_HASH_TABLE_SIZE];
1588     else
1589         entry = (*handle)->next;
1590
1591     while (entry && entry->value != val)
1592         entry = entry->next;
1593
1594     *handle = entry;
1595     if (!entry)
1596         return ERROR_NO_MORE_ITEMS;
1597
1598     *row = entry->row;
1599     return ERROR_SUCCESS;
1600 }
1601
1602
1603 static const MSIVIEWOPS table_ops =
1604 {
1605     TABLE_fetch_int,
1606     TABLE_fetch_stream,
1607     TABLE_set_row,
1608     TABLE_insert_row,
1609     TABLE_execute,
1610     TABLE_close,
1611     TABLE_get_dimensions,
1612     TABLE_get_column_info,
1613     TABLE_modify,
1614     TABLE_delete,
1615     TABLE_find_matching_rows
1616 };
1617
1618 UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
1619 {
1620     MSITABLEVIEW *tv ;
1621     UINT r, sz, column_count;
1622     MSICOLUMNINFO *columns;
1623
1624     TRACE("%p %s %p\n", db, debugstr_w(name), view );
1625
1626     /* get the number of columns in this table */
1627     column_count = 0;
1628     r = get_tablecolumns( db, name, NULL, &column_count );
1629     if( r != ERROR_SUCCESS )
1630         return r;
1631
1632     /* if there's no columns, there's no table */
1633     if( column_count == 0 )
1634         return ERROR_INVALID_PARAMETER;
1635
1636     TRACE("Table found\n");
1637
1638     sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ;
1639     tv = msi_alloc_zero( sz );
1640     if( !tv )
1641         return ERROR_FUNCTION_FAILED;
1642     
1643     columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO));
1644     if( !columns )
1645     {
1646         msi_free( tv );
1647         return ERROR_FUNCTION_FAILED;
1648     }
1649
1650     r = get_tablecolumns( db, name, columns, &column_count );
1651     if( r != ERROR_SUCCESS )
1652     {
1653         msi_free( columns );
1654         msi_free( tv );
1655         return ERROR_FUNCTION_FAILED;
1656     }
1657
1658     TRACE("Table has %d columns\n", column_count);
1659
1660     /* fill the structure */
1661     tv->view.ops = &table_ops;
1662     tv->db = db;
1663     tv->columns = columns;
1664     tv->num_cols = column_count;
1665     tv->table = NULL;
1666     tv->row_size = msi_table_get_row_size( columns, column_count );
1667
1668     TRACE("%s one row is %d bytes\n", debugstr_w(name), tv->row_size );
1669
1670     *view = (MSIVIEW*) tv;
1671     lstrcpyW( tv->name, name );
1672
1673     return ERROR_SUCCESS;
1674 }
1675
1676 UINT MSI_CommitTables( MSIDATABASE *db )
1677 {
1678     UINT r;
1679     MSITABLE *table = NULL;
1680
1681     TRACE("%p\n",db);
1682
1683     r = save_string_table( db );
1684     if( r != ERROR_SUCCESS )
1685     {
1686         WARN("failed to save string table r=%08x\n",r);
1687         return r;
1688     }
1689
1690     LIST_FOR_EACH_ENTRY( table, &db->tables, MSITABLE, entry )
1691     {
1692         r = save_table( db, table );
1693         if( r != ERROR_SUCCESS )
1694         {
1695             WARN("failed to save table %s (r=%08x)\n",
1696                   debugstr_w(table->name), r);
1697             return r;
1698         }
1699     }
1700
1701     /* force everything to reload next time */
1702     free_cached_tables( db );
1703
1704     return ERROR_SUCCESS;
1705 }
1706
1707 MSICONDITION MSI_DatabaseIsTablePersistent( MSIDATABASE *db, LPCWSTR table )
1708 {
1709     if (!table)
1710         return MSICONDITION_ERROR;
1711
1712     return MSICONDITION_FALSE;
1713 }
1714
1715 static MSIRECORD *msi_get_transform_record( MSITABLEVIEW *tv, string_table *st, USHORT *rawdata )
1716 {
1717     UINT i, val, ofs = 0;
1718     USHORT mask = *rawdata++;
1719     MSICOLUMNINFO *columns = tv->columns;
1720     MSIRECORD *rec;
1721
1722     rec = MSI_CreateRecord( tv->num_cols );
1723     if( !rec )
1724         return rec;
1725
1726     TRACE("row ->\n");
1727     for( i=0; i<tv->num_cols; i++ )
1728     {
1729         UINT n = bytes_per_column( &columns[i] );
1730
1731         if ( (mask&1) && (i>=(mask>>8)) )
1732             break;
1733         /* all keys must be present */
1734         if ( (~mask&1) && (~columns[i].type & MSITYPE_KEY) && ((1<<i) & ~mask) )
1735             continue;
1736
1737         switch( n )
1738         {
1739         case 2:
1740             val = rawdata[ofs];
1741             if( (columns[i].type & MSITYPE_STRING) &&
1742                 ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1743             {
1744                 LPCWSTR sval = msi_string_lookup_id( st, val );
1745                 MSI_RecordSetStringW( rec, i+1, sval );
1746                 TRACE(" field %d [%s]\n", i+1, debugstr_w(sval));
1747             }
1748             else
1749             {
1750                 if (val)
1751                     MSI_RecordSetInteger( rec, i+1, val^0x8000 );
1752                 TRACE(" field %d [0x%04x]\n", i+1, val );
1753             }
1754             break;
1755         case 4:
1756             val = (rawdata[ofs] + (rawdata[ofs + 1]<<16));
1757             if (val)
1758                 MSI_RecordSetInteger( rec, i+1, val^0x80000000 );
1759             TRACE(" field %d [0x%08x]\n", i+1, val );
1760             break;
1761         default:
1762             ERR("oops - unknown column width %d\n", n);
1763             break;
1764         }
1765         ofs += n/2;
1766     }
1767     return rec;
1768 }
1769
1770 static void dump_record( MSIRECORD *rec )
1771 {
1772     UINT i, n;
1773
1774     n = MSI_RecordGetFieldCount( rec );
1775     for( i=1; i<=n; i++ )
1776     {
1777         LPCWSTR sval = MSI_RecordGetString( rec, i );
1778
1779         if( MSI_RecordIsNull( rec, i ) )
1780             TRACE("row -> []\n");
1781         else if( (sval = MSI_RecordGetString( rec, i )) )
1782             TRACE("row -> [%s]\n", debugstr_w(sval));
1783         else
1784             TRACE("row -> [0x%08x]\n", MSI_RecordGetInteger( rec, i ) );
1785     }
1786 }
1787
1788 static void dump_table( string_table *st, USHORT *rawdata, UINT rawsize )
1789 {
1790     LPCWSTR sval;
1791     UINT i;
1792
1793     for( i=0; i<(rawsize/2); i++ )
1794     {
1795         sval = msi_string_lookup_id( st, rawdata[i] );
1796         MESSAGE(" %04x %s\n", rawdata[i], debugstr_w(sval) );
1797     }
1798 }
1799
1800 static UINT* msi_record_to_row( MSITABLEVIEW *tv, MSIRECORD *rec )
1801 {
1802     LPCWSTR str;
1803     UINT i, r, *data;
1804
1805     data = msi_alloc( tv->num_cols *sizeof (UINT) );
1806     for( i=0; i<tv->num_cols; i++ )
1807     {
1808         data[i] = 0;
1809
1810         if ( ~tv->columns[i].type & MSITYPE_KEY )
1811             continue;
1812
1813         /* turn the transform column value into a row value */
1814         if ( ( tv->columns[i].type & MSITYPE_STRING ) &&
1815              ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1816         {
1817             str = MSI_RecordGetString( rec, i+1 );
1818             r = msi_string2idW( tv->db->strings, str, &data[i] );
1819
1820             /* if there's no matching string in the string table,
1821                these keys can't match any record, so fail now. */
1822             if( ERROR_SUCCESS != r )
1823             {
1824                 msi_free( data );
1825                 return NULL;
1826             }
1827         }
1828         else
1829         {
1830             data[i] = MSI_RecordGetInteger( rec, i+1 );
1831             if ((tv->columns[i].type&0xff) == 2)
1832                 data[i] += 0x8000;
1833             else
1834                 data[i] += 0x80000000;
1835         }
1836     }
1837     return data;
1838 }
1839
1840 static UINT msi_row_matches( MSITABLEVIEW *tv, UINT row, UINT *data )
1841 {
1842     UINT i, r, x, ret = ERROR_FUNCTION_FAILED;
1843
1844     for( i=0; i<tv->num_cols; i++ )
1845     {
1846         if ( ~tv->columns[i].type & MSITYPE_KEY )
1847             continue;
1848
1849         /* turn the transform column value into a row value */
1850         r = TABLE_fetch_int( &tv->view, row, i+1, &x );
1851         if ( r != ERROR_SUCCESS )
1852         {
1853             ERR("TABLE_fetch_int shouldn't fail here\n");
1854             break;
1855         }
1856
1857         /* if this key matches, move to the next column */
1858         if ( x != data[i] )
1859         {
1860             ret = ERROR_FUNCTION_FAILED;
1861             break;
1862         }
1863
1864         ret = ERROR_SUCCESS;
1865     }
1866
1867     return ret;
1868 }
1869
1870 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row )
1871 {
1872     UINT i, r = ERROR_FUNCTION_FAILED, *data;
1873
1874     data = msi_record_to_row( tv, rec );
1875     if( !data )
1876         return r;
1877     for( i=0; i<tv->table->row_count; i++ )
1878     {
1879         r = msi_row_matches( tv, i, data );
1880         if( r == ERROR_SUCCESS )
1881         {
1882             *row = i;
1883             break;
1884         }
1885     }
1886     msi_free( data );
1887     return r;
1888 }
1889
1890 static UINT msi_delete_row( MSITABLEVIEW *tv, UINT row )
1891 {
1892     UINT i;
1893
1894     for( i=1; i<=tv->num_cols; i++ )
1895         TABLE_set_int( tv, row, i, 0 );
1896     return ERROR_SUCCESS;
1897 }
1898
1899 static UINT msi_table_load_transform( MSIDATABASE *db, IStorage *stg,
1900                                       string_table *st, LPCWSTR name )
1901 {
1902     UINT rawsize = 0;
1903     USHORT *rawdata = NULL;
1904     MSITABLEVIEW *tv = NULL;
1905     UINT r, n, sz, i, mask;
1906     MSIRECORD *rec = NULL;
1907     UINT colcol = 0;
1908     WCHAR coltable[32];
1909
1910     coltable[0] = 0;
1911     TRACE("%p %p %p %s\n", db, stg, st, debugstr_w(name) );
1912
1913     /* read the transform data */
1914     read_stream_data( stg, name, &rawdata, &rawsize );
1915     if ( !rawdata )
1916     {
1917         TRACE("table %s empty\n", debugstr_w(name) );
1918         return ERROR_INVALID_TABLE;
1919     }
1920
1921     /* create a table view */
1922     r = TABLE_CreateView( db, name, (MSIVIEW**) &tv );
1923     if( r != ERROR_SUCCESS )
1924         goto err;
1925
1926     r = tv->view.ops->execute( &tv->view, NULL );
1927     if( r != ERROR_SUCCESS )
1928         goto err;
1929
1930     TRACE("name = %s columns = %u row_size = %u raw size = %u\n",
1931           debugstr_w(name), tv->num_cols, tv->row_size, rawsize );
1932
1933     /* interpret the data */
1934     r = ERROR_SUCCESS;
1935     for( n=0; n < (rawsize/2);  )
1936     {
1937         mask = rawdata[n];
1938
1939         if (mask&1)
1940         {
1941             /*
1942              * if the low bit is set, columns are continuous and
1943              * the number of columns is specified in the high byte
1944              */
1945             sz = 2 + tv->row_size;
1946         }
1947         else
1948         {
1949             /*
1950              * If the low bit is not set, rowdata[n] is a bitmask.
1951              * Excepting for key fields, which are always present,
1952              *  each bit indicates that a field is present in the transform record.
1953              *
1954              * rawdata[n] == 0 is a special case ... only the keys will be present
1955              * and it means that this row should be deleted.
1956              */
1957             sz = 2;
1958             for( i=0; i<tv->num_cols; i++ )
1959             {
1960                 if( (tv->columns[i].type & MSITYPE_KEY) || ((1<<i)&mask))
1961                     sz += bytes_per_column( &tv->columns[i] );
1962             }
1963         }
1964
1965         /* check we didn't run of the end of the table */
1966         if ( (n+sz) > rawsize )
1967         {
1968             ERR("borked.\n");
1969             dump_table( st, rawdata, rawsize );
1970             break;
1971         }
1972
1973         rec = msi_get_transform_record( tv, st, &rawdata[n] );
1974         if (rec)
1975         {
1976             if ( mask & 1 )
1977             {
1978                 TRACE("inserting record\n");
1979
1980                 /*
1981                  * Native msi seems writes nul into the
1982                  * Number (2nd) column of the _Columns table.
1983                  * Not sure that it's deliberate...
1984                  */
1985                 if (!lstrcmpW(name, szColumns))
1986                 {
1987                     WCHAR table[32];
1988                     DWORD sz = 32;
1989
1990                     MSI_RecordGetStringW( rec, 1, table, &sz );
1991
1992                     /* reset the column number on a new table */
1993                     if ( lstrcmpW(coltable, table) )
1994                     {
1995                         colcol = 0;
1996                         lstrcpyW( coltable, table );
1997                     }
1998
1999                     /* fix nul column numbers */
2000                     MSI_RecordSetInteger( rec, 2, ++colcol );
2001                 }
2002
2003                 r = TABLE_insert_row( &tv->view, rec );
2004                 if (r != ERROR_SUCCESS)
2005                     ERR("insert row failed\n");
2006             }
2007             else
2008             {
2009                 UINT row = 0;
2010
2011                 r = msi_table_find_row( tv, rec, &row );
2012                 if (r != ERROR_SUCCESS)
2013                     ERR("no matching row to transform\n");
2014                 else if ( mask )
2015                 {
2016                     TRACE("modifying row [%d]:\n", row);
2017                     TABLE_set_row( &tv->view, row, rec, mask );
2018                 }
2019                 else
2020                 {
2021                     TRACE("deleting row [%d]:\n", row);
2022                     msi_delete_row( tv, row );
2023                 }
2024             }
2025             if( TRACE_ON(msidb) ) dump_record( rec );
2026             msiobj_release( &rec->hdr );
2027         }
2028
2029         n += sz/2;
2030     }
2031
2032 err:
2033     /* no need to free the table, it's associated with the database */
2034     msi_free( rawdata );
2035     if( tv )
2036         tv->view.ops->delete( &tv->view );
2037
2038     return ERROR_SUCCESS;
2039 }
2040
2041 /*
2042  * msi_table_apply_transform
2043  *
2044  * Enumerate the table transforms in a transform storage and apply each one.
2045  */
2046 UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
2047 {
2048     IEnumSTATSTG *stgenum = NULL;
2049     HRESULT r;
2050     STATSTG stat;
2051     ULONG count;
2052     WCHAR name[0x40];
2053     string_table *strings;
2054     UINT ret = ERROR_FUNCTION_FAILED;
2055
2056     TRACE("%p %p\n", db, stg );
2057
2058     strings = load_string_table( stg );
2059     if( !strings )
2060         goto end;
2061
2062     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
2063     if( FAILED( r ) )
2064         goto end;
2065
2066     /*
2067      * Apply _Tables and _Columns transforms first so that
2068      * the table metadata is correct, and empty tables exist.
2069      */
2070     ret = msi_table_load_transform( db, stg, strings, szTables );
2071     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
2072         goto end;
2073
2074     ret = msi_table_load_transform( db, stg, strings, szColumns );
2075     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
2076         goto end;
2077
2078     ret = ERROR_SUCCESS;
2079
2080     while( r == ERROR_SUCCESS )
2081     {
2082         count = 0;
2083         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
2084         if( FAILED( r ) || !count )
2085             break;
2086
2087         decode_streamname( stat.pwcsName, name );
2088         if ( name[0] != 0x4840 )
2089             continue;
2090
2091         TRACE("transform contains stream %s\n", debugstr_w(name));
2092
2093         if ( !lstrcmpW( name+1, szStringPool ) ||
2094              !lstrcmpW( name+1, szStringData ) ||
2095              !lstrcmpW( name+1, szColumns ) ||
2096              !lstrcmpW( name+1, szTables ) )
2097             continue;
2098
2099         ret = msi_table_load_transform( db, stg, strings, name+1 );
2100     }
2101
2102     if ( ret == ERROR_SUCCESS )
2103         append_storage_to_db( db, stg );
2104
2105 end:
2106     if ( stgenum )
2107         IEnumSTATSTG_Release( stgenum );
2108     if ( strings )
2109         msi_destroy_stringtable( strings );
2110
2111     return ret;
2112 }
2113
2114 void append_storage_to_db( MSIDATABASE *db, IStorage *stg )
2115 {
2116     MSITRANSFORM *t;
2117
2118     t = msi_alloc( sizeof *t );
2119     t->stg = stg;
2120     IStorage_AddRef( stg );
2121     list_add_tail( &db->transforms, &t->entry );
2122 }
2123
2124 void msi_free_transforms( MSIDATABASE *db )
2125 {
2126     while( !list_empty( &db->transforms ) )
2127     {
2128         MSITRANSFORM *t = LIST_ENTRY( list_head( &db->transforms ),
2129                                       MSITRANSFORM, entry );
2130         list_remove( &t->entry );
2131         IStorage_Release( t->stg );
2132         msi_free( t );
2133     }
2134 }