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