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         pool[ n*2 + 1 ] = msi_id_refcount( db->strings, i );
 808         if (sz < 0x10000)
 809         {
 810             pool[ n*2 ] = sz;
 811             n++;
 812         }
 813         else
 814         {
 815             pool[ n*2 ] = 0;
 816             pool[ n*2 + 2 ] = sz&0xffff;
 817             pool[ n*2 + 3 ] = (sz>>16);
 818             n += 2;
 819         }
 820         used += sz;
 821         if( used > datasize  )
 822         {
 823             ERR("oops overran %d >= %d\n", used, datasize);
 824             goto err;
 825         }
 826     }
 827
 828     if( used != datasize )
 829     {
 830         ERR("oops used %d != datasize %d\n", used, datasize);
 831         goto err;
 832     }
 833
 834     /* write the streams */
 835     r = write_stream_data( db->storage, szStringData, data, datasize );
 836     TRACE("Wrote StringData r=%08x\n", r);
 837     if( r )
 838         goto err;
 839     r = write_stream_data( db->storage, szStringPool, pool, poolsize );
 840     TRACE("Wrote StringPool r=%08x\n", r);
 841     if( r )
 842         goto err;
 843
 844     ret = ERROR_SUCCESS;
 845
 846 err:
 847     msi_free( data );
 848     msi_free( pool );
 849
 850     return ret;
 851 }
 852
 853 /* information for default tables */
 854 static const WCHAR szTables[]  = { '_','T','a','b','l','e','s',0 };
 855 static const WCHAR szTable[]  = { 'T','a','b','l','e',0 };
 856 static const WCHAR szName[]    = { 'N','a','m','e',0 };
 857 static const WCHAR szColumns[] = { '_','C','o','l','u','m','n','s',0 };
 858 static const WCHAR szColumn[]  = { 'C','o','l','u','m','n',0 };
 859 static const WCHAR szNumber[]  = { 'N','u','m','b','e','r',0 };
 860 static const WCHAR szType[]    = { 'T','y','p','e',0 };
 861
 862 static const MSICOLUMNINFO _Columns_cols[4] = {
 863     { szColumns, 1, szTable,  MSITYPE_VALID | MSITYPE_STRING | 64, 0 },
 864     { szColumns, 2, szNumber, MSITYPE_VALID | 2,                   2 },
 865     { szColumns, 3, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 4 },
 866     { szColumns, 4, szType,   MSITYPE_VALID | 2,                   6 },
 867 };
 868 static const MSICOLUMNINFO _Tables_cols[1] = {
 869     { szTables,  1, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 0 },
 870 };
 871
 872 static UINT get_defaulttablecolumns( LPCWSTR name, MSICOLUMNINFO *colinfo, UINT *sz)
 873 {
 874     const MSICOLUMNINFO *p;
 875     DWORD i, n;
 876
 877     TRACE("%s\n", debugstr_w(name));
 878
 879     if (!lstrcmpW( name, szTables ))
 880     {
 881         p = _Tables_cols;
 882         n = 1;
 883     }
 884     else if (!lstrcmpW( name, szColumns ))
 885     {
 886         p = _Columns_cols;
 887         n = 4;
 888     }
 889     else
 890         return ERROR_FUNCTION_FAILED;
 891
 892     /* duplicate the string data so we can free it in msi_free_colinfo */
 893     for (i=0; i<n; i++)
 894     {
 895         if (colinfo && (i < *sz) )
 896         {
 897             memcpy( &colinfo[i], &p[i], sizeof(MSICOLUMNINFO) );
 898             colinfo[i].tablename = strdupW( p[i].tablename );
 899             colinfo[i].colname = strdupW( p[i].colname );
 900         }
 901         if( colinfo && (i >= *sz) )
 902             break;
 903     }
 904     *sz = n;
 905     return ERROR_SUCCESS;
 906 }
 907
 908 static void msi_free_colinfo( MSICOLUMNINFO *colinfo, UINT count )
 909 {
 910     UINT i;
 911
 912     for( i=0; i<count; i++ )
 913     {
 914         msi_free( (LPWSTR) colinfo[i].tablename );
 915         msi_free( (LPWSTR) colinfo[i].colname );
 916         msi_free( colinfo[i].hash_table );
 917     }
 918 }
 919
 920 static LPWSTR msi_makestring( MSIDATABASE *db, UINT stringid)
 921 {
 922     return strdupW(msi_string_lookup_id( db->strings, stringid ));
 923 }
 924
 925 static UINT get_tablecolumns( MSIDATABASE *db,
 926        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz)
 927 {
 928     UINT r, i, n=0, table_id, count, maxcount = *sz;
 929     MSITABLE *table = NULL;
 930
 931     /* first check if there is a default table with that name */
 932     r = get_defaulttablecolumns( szTableName, colinfo, sz );
 933     if( ( r == ERROR_SUCCESS ) && *sz )
 934         return r;
 935
 936     table = get_table( db, szColumns, _Columns_cols, 4 );
 937     if( !table )
 938     {
 939         ERR("couldn't load _Columns table\n");
 940         return ERROR_FUNCTION_FAILED;
 941     }
 942
 943     /* convert table and column names to IDs from the string table */
 944     r = msi_string2idW( db->strings, szTableName, &table_id );
 945     if( r != ERROR_SUCCESS )
 946     {
 947         WARN("Couldn't find id for %s\n", debugstr_w(szTableName));
 948         return r;
 949     }
 950
 951     TRACE("Table id is %d, row count is %d\n", table_id, table->row_count);
 952
 953     count = table->row_count;
 954     for( i=0; i<count; i++ )
 955     {
 956         if( table->data[ i ][ 0 ] != table_id )
 957             continue;
 958         if( colinfo )
 959         {
 960             UINT id = table->data[ i ] [ 2 ];
 961             colinfo[n].tablename = msi_makestring( db, table_id );
 962             colinfo[n].number = table->data[ i ][ 1 ] - (1<<15);
 963             colinfo[n].colname = msi_makestring( db, id );
 964             colinfo[n].type = table->data[ i ] [ 3 ] ^ 0x8000;
 965             colinfo[n].hash_table = NULL;
 966             /* this assumes that columns are in order in the table */
 967             if( n )
 968                 colinfo[n].offset = colinfo[n-1].offset
 969                                   + bytes_per_column( &colinfo[n-1] );
 970             else
 971                 colinfo[n].offset = 0;
 972             TRACE("table %s column %d is [%s] (%d) with type %08x "
 973                   "offset %d at row %d\n", debugstr_w(szTableName),
 974                    colinfo[n].number, debugstr_w(colinfo[n].colname),
 975                    id, colinfo[n].type, colinfo[n].offset, i);
 976             if( n != (colinfo[n].number-1) )
 977             {
 978                 ERR("oops. data in the _Columns table isn't in the right "
 979                     "order for table %s\n", debugstr_w(szTableName));
 980                 msi_free_colinfo(colinfo, n+1 );
 981                 return ERROR_FUNCTION_FAILED;
 982             }
 983         }
 984         n++;
 985         if( colinfo && ( n >= maxcount ) )
 986             break;
 987     }
 988     *sz = n;
 989
 990     return ERROR_SUCCESS;
 991 }
 992
 993 /* try to find the table name in the _Tables table */
 994 BOOL TABLE_Exists( MSIDATABASE *db, LPWSTR name )
 995 {
 996     UINT r, table_id = 0, i, count;
 997     MSITABLE *table = NULL;
 998
 999     if( !lstrcmpW( name, szTables ) )
1000         return TRUE;
1001     if( !lstrcmpW( name, szColumns ) )
1002         return TRUE;
1003
1004     r = msi_string2idW( db->strings, name, &table_id );
1005     if( r != ERROR_SUCCESS )
1006     {
1007         TRACE("Couldn't find id for %s\n", debugstr_w(name));
1008         return FALSE;
1009     }
1010
1011     table = get_table( db, szTables, _Tables_cols, 1 );
1012     if( !table )
1013     {
1014         TRACE("table %s not available\n", debugstr_w(szTables));
1015         return FALSE;
1016     }
1017
1018     /* count = table->size/2; */
1019     count = table->row_count;
1020     for( i=0; i<count; i++ )
1021         if( table->data[ i ][ 0 ] == table_id )
1022             break;
1023
1024     if (i!=count)
1025         return TRUE;
1026
1027     TRACE("Searched %d tables, but %d was not found\n", count, table_id );
1028
1029     return FALSE;
1030 }
1031
1032 /* below is the query interface to a table */
1033
1034 typedef struct tagMSITABLEVIEW
1035 {
1036     MSIVIEW        view;
1037     MSIDATABASE   *db;
1038     MSITABLE      *table;
1039     MSICOLUMNINFO *columns;
1040     UINT           num_cols;
1041     UINT           row_size;
1042     WCHAR          name[1];
1043 } MSITABLEVIEW;
1044
1045 static UINT TABLE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
1046 {
1047     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1048     UINT offset, num_rows, n;
1049
1050     if( !tv->table )
1051         return ERROR_INVALID_PARAMETER;
1052
1053     if( (col==0) || (col>tv->num_cols) )
1054         return ERROR_INVALID_PARAMETER;
1055
1056     /* how many rows are there ? */
1057     num_rows = tv->table->row_count;
1058     if( row >= num_rows )
1059         return ERROR_NO_MORE_ITEMS;
1060
1061     if( tv->columns[col-1].offset >= tv->row_size )
1062     {
1063         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1064         ERR("%p %p\n", tv, tv->columns );
1065         return ERROR_FUNCTION_FAILED;
1066     }
1067
1068     offset = row + (tv->columns[col-1].offset/2) * num_rows;
1069     n = bytes_per_column( &tv->columns[col-1] );
1070     switch( n )
1071     {
1072     case 4:
1073         offset = tv->columns[col-1].offset/2;
1074         *val = tv->table->data[row][offset] +
1075                (tv->table->data[row][offset + 1] << 16);
1076         break;
1077     case 2:
1078         offset = tv->columns[col-1].offset/2;
1079         *val = tv->table->data[row][offset];
1080         break;
1081     default:
1082         ERR("oops! what is %d bytes per column?\n", n );
1083         return ERROR_FUNCTION_FAILED;
1084     }
1085
1086     /* TRACE("Data [%d][%d] = %d\n", row, col, *val ); */
1087
1088     return ERROR_SUCCESS;
1089 }
1090
1091 /*
1092  * We need a special case for streams, as we need to reference column with
1093  * the name of the stream in the same table, and the table name
1094  * which may not be available at higher levels of the query
1095  */
1096 static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
1097 {
1098     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1099     UINT ival = 0, refcol = 0, r;
1100     LPCWSTR sval;
1101     LPWSTR full_name;
1102     DWORD len;
1103     static const WCHAR szDot[] = { '.', 0 };
1104
1105     if( !view->ops->fetch_int )
1106         return ERROR_INVALID_PARAMETER;
1107
1108     /*
1109      * The column marked with the type stream data seems to have a single number
1110      * which references the column containing the name of the stream data
1111      *
1112      * Fetch the column to reference first.
1113      */
1114     r = view->ops->fetch_int( view, row, col, &ival );
1115     if( r != ERROR_SUCCESS )
1116         return r;
1117
1118     /* now get the column with the name of the stream */
1119     r = view->ops->fetch_int( view, row, ival, &refcol );
1120     if( r != ERROR_SUCCESS )
1121         return r;
1122
1123     /* lookup the string value from the string table */
1124     sval = msi_string_lookup_id( tv->db->strings, refcol );
1125     if( !sval )
1126         return ERROR_INVALID_PARAMETER;
1127
1128     len = lstrlenW( tv->name ) + 2 + lstrlenW( sval );
1129     full_name = msi_alloc( len*sizeof(WCHAR) );
1130     lstrcpyW( full_name, tv->name );
1131     lstrcatW( full_name, szDot );
1132     lstrcatW( full_name, sval );
1133
1134     r = db_get_raw_stream( tv->db, full_name, stm );
1135     if( r )
1136         ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r);
1137     msi_free( full_name );
1138
1139     return r;
1140 }
1141
1142 static UINT TABLE_set_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT val )
1143 {
1144     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1145     UINT offset, n;
1146
1147     if( !tv->table )
1148         return ERROR_INVALID_PARAMETER;
1149
1150     if( (col==0) || (col>tv->num_cols) )
1151         return ERROR_INVALID_PARAMETER;
1152
1153     if( tv->columns[col-1].offset >= tv->row_size )
1154     {
1155         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1156         ERR("%p %p\n", tv, tv->columns );
1157         return ERROR_FUNCTION_FAILED;
1158     }
1159
1160     n = bytes_per_column( &tv->columns[col-1] );
1161     switch( n )
1162     {
1163     case 4:
1164         offset = tv->columns[col-1].offset/2;
1165         tv->table->data[row][offset]     = val & 0xffff;
1166         tv->table->data[row][offset + 1] = (val>>16)&0xffff;
1167         break;
1168     case 2:
1169         offset = tv->columns[col-1].offset/2;
1170         tv->table->data[row][offset] = val;
1171         break;
1172     default:
1173         ERR("oops! what is %d bytes per column?\n", n );
1174         return ERROR_FUNCTION_FAILED;
1175     }
1176     return ERROR_SUCCESS;
1177 }
1178
1179 static UINT table_create_new_row( struct tagMSIVIEW *view, UINT *num )
1180 {
1181     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1182     USHORT **p, *row;
1183     UINT sz;
1184
1185     TRACE("%p\n", view);
1186
1187     if( !tv->table )
1188         return ERROR_INVALID_PARAMETER;
1189
1190     row = msi_alloc_zero( tv->row_size );
1191     if( !row )
1192         return ERROR_NOT_ENOUGH_MEMORY;
1193
1194     sz = (tv->table->row_count + 1) * sizeof (UINT*);
1195     if( tv->table->data )
1196         p = msi_realloc( tv->table->data, sz );
1197     else
1198         p = msi_alloc( sz );
1199     if( !p )
1200     {
1201         msi_free( row );
1202         return ERROR_NOT_ENOUGH_MEMORY;
1203     }
1204
1205     tv->table->data = p;
1206     tv->table->data[tv->table->row_count] = row;
1207     *num = tv->table->row_count;
1208     tv->table->row_count++;
1209
1210     return ERROR_SUCCESS;
1211 }
1212
1213 static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
1214 {
1215     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1216
1217     TRACE("%p %p\n", tv, record);
1218
1219     TRACE("There are %d columns\n", tv->num_cols );
1220     tv->table = get_table( tv->db, tv->name, tv->columns, tv->num_cols );
1221     if( !tv->table )
1222         return ERROR_FUNCTION_FAILED;
1223
1224     return ERROR_SUCCESS;
1225 }
1226
1227 static UINT TABLE_close( struct tagMSIVIEW *view )
1228 {
1229     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1230
1231     TRACE("%p\n", view );
1232
1233     if( !tv->table )
1234         return ERROR_FUNCTION_FAILED;
1235
1236     tv->table = NULL;
1237
1238     return ERROR_SUCCESS;
1239 }
1240
1241 static UINT TABLE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols)
1242 {
1243     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1244
1245     TRACE("%p %p %p\n", view, rows, cols );
1246
1247     if( cols )
1248         *cols = tv->num_cols;
1249     if( rows )
1250     {
1251         if( !tv->table )
1252             return ERROR_INVALID_PARAMETER;
1253         *rows = tv->table->row_count;
1254     }
1255
1256     return ERROR_SUCCESS;
1257 }
1258
1259 static UINT TABLE_get_column_info( struct tagMSIVIEW *view,
1260                 UINT n, LPWSTR *name, UINT *type )
1261 {
1262     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1263
1264     TRACE("%p %d %p %p\n", tv, n, name, type );
1265
1266     if( ( n == 0 ) || ( n > tv->num_cols ) )
1267         return ERROR_INVALID_PARAMETER;
1268
1269     if( name )
1270     {
1271         *name = strdupW( tv->columns[n-1].colname );
1272         if( !*name )
1273             return ERROR_FUNCTION_FAILED;
1274     }
1275     if( type )
1276         *type = tv->columns[n-1].type;
1277
1278     return ERROR_SUCCESS;
1279 }
1280
1281 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row );
1282
1283 static UINT table_validate_new( MSITABLEVIEW *tv, MSIRECORD *rec )
1284 {
1285     UINT r, row, i;
1286
1287     /* check there's no null values where they're not allowed */
1288     for( i = 0; i < tv->num_cols; i++ )
1289     {
1290         if ( tv->columns[i].type & MSITYPE_NULLABLE )
1291             continue;
1292
1293         if ( tv->columns[i].type & MSITYPE_STRING )
1294         {
1295             LPCWSTR str;
1296
1297             str = MSI_RecordGetString( rec, i+1 );
1298             if (str == NULL || str[0] == 0)
1299                 return ERROR_INVALID_DATA;
1300         }
1301         else
1302         {
1303             UINT n;
1304
1305             n = MSI_RecordGetInteger( rec, i+1 );
1306             if (n == MSI_NULL_INTEGER)
1307                 return ERROR_INVALID_DATA;
1308         }
1309     }
1310
1311     /* check there's no duplicate keys */
1312     r = msi_table_find_row( tv, rec, &row );
1313     if (r == ERROR_SUCCESS)
1314         return ERROR_INVALID_DATA;
1315
1316     return ERROR_SUCCESS;
1317 }
1318
1319 static UINT msi_table_modify_row( MSITABLEVIEW *tv, MSIRECORD *rec,
1320                                   UINT row, UINT mask )
1321 {
1322     UINT i, val, r = ERROR_SUCCESS;
1323
1324     TRACE("%p %p %u %08x\n", tv, rec, row, mask );
1325
1326     for( i = 0; i < tv->num_cols; i++ )
1327     {
1328         /* set keys or values specified in the mask */
1329         if( (~tv->columns[i].type & MSITYPE_KEY) && (~mask & (1<<i)) )
1330             continue;
1331
1332         if( (tv->columns[i].type & MSITYPE_STRING) &&
1333             ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1334         {
1335             const WCHAR *str = MSI_RecordGetString( rec, i+1 );
1336             val = msi_addstringW( tv->db->strings, 0, str, -1, 1 );
1337         }
1338         else
1339         {
1340             val = MSI_RecordGetInteger( rec, i+1 );
1341             if ( 2 == bytes_per_column( &tv->columns[i] ) )
1342                 val ^= 0x8000;
1343             else
1344                 val ^= 0x80000000;
1345         }
1346         r = TABLE_set_int( &tv->view, row, i+1, val );
1347         if( r )
1348             break;
1349     }
1350
1351     return r;
1352 }
1353
1354 static UINT TABLE_insert_row( struct tagMSIVIEW *view, MSIRECORD *rec )
1355 {
1356     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1357     UINT r, row = -1;
1358
1359     TRACE("%p %p\n", tv, rec );
1360
1361     /* check that the key is unique - can we find a matching row? */
1362     r = table_validate_new( tv, rec );
1363     if( r != ERROR_SUCCESS )
1364         return ERROR_FUNCTION_FAILED;
1365
1366     r = table_create_new_row( view, &row );
1367     TRACE("insert_row returned %08x\n", r);
1368     if( r != ERROR_SUCCESS )
1369         return r;
1370
1371     return msi_table_modify_row( tv, rec, row, ~0 );
1372 }
1373
1374 static UINT TABLE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
1375                 MSIRECORD *rec)
1376 {
1377     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1378     UINT r;
1379
1380     TRACE("%p %d %p\n", view, eModifyMode, rec );
1381
1382     if (!tv->table)
1383     {
1384         r = TABLE_execute( view, NULL );
1385         if( r )
1386             return r;
1387     }
1388
1389     switch (eModifyMode)
1390     {
1391     case MSIMODIFY_VALIDATE_NEW:
1392         r = table_validate_new( tv, rec );
1393         break;
1394
1395     case MSIMODIFY_INSERT_TEMPORARY:
1396         r = table_validate_new( tv, rec );
1397         if (r != ERROR_SUCCESS)
1398             break;
1399         r = TABLE_insert_row( view, rec );
1400         break;
1401
1402     case MSIMODIFY_REFRESH:
1403     case MSIMODIFY_INSERT:
1404     case MSIMODIFY_UPDATE:
1405     case MSIMODIFY_ASSIGN:
1406     case MSIMODIFY_REPLACE:
1407     case MSIMODIFY_MERGE:
1408     case MSIMODIFY_DELETE:
1409     case MSIMODIFY_VALIDATE:
1410     case MSIMODIFY_VALIDATE_FIELD:
1411     case MSIMODIFY_VALIDATE_DELETE:
1412         FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
1413         r = ERROR_CALL_NOT_IMPLEMENTED;
1414         break;
1415
1416     default:
1417         r = ERROR_INVALID_DATA;
1418     }
1419
1420     return r;
1421 }
1422
1423 static UINT TABLE_delete( struct tagMSIVIEW *view )
1424 {
1425     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1426
1427     TRACE("%p\n", view );
1428
1429     tv->table = NULL;
1430
1431     if( tv->columns )
1432     {
1433         msi_free_colinfo( tv->columns, tv->num_cols );
1434         msi_free( tv->columns );
1435     }
1436     tv->columns = NULL;
1437
1438     msi_free( tv );
1439
1440     return ERROR_SUCCESS;
1441 }
1442
1443 static UINT TABLE_find_matching_rows( struct tagMSIVIEW *view, UINT col,
1444     UINT val, UINT *row, MSIITERHANDLE *handle )
1445 {
1446     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1447     const MSICOLUMNHASHENTRY *entry;
1448
1449     TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
1450
1451     if( !tv->table )
1452         return ERROR_INVALID_PARAMETER;
1453
1454     if( (col==0) || (col > tv->num_cols) )
1455         return ERROR_INVALID_PARAMETER;
1456
1457     if( !tv->columns[col-1].hash_table )
1458     {
1459         UINT i;
1460         UINT num_rows = tv->table->row_count;
1461         MSICOLUMNHASHENTRY **hash_table;
1462         MSICOLUMNHASHENTRY *new_entry;
1463
1464         if( tv->columns[col-1].offset >= tv->row_size )
1465         {
1466             ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1467             ERR("%p %p\n", tv, tv->columns );
1468             return ERROR_FUNCTION_FAILED;
1469         }
1470
1471         /* allocate contiguous memory for the table and its entries so we
1472          * don't have to do an expensive cleanup */
1473         hash_table = msi_alloc(MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*) +
1474             num_rows * sizeof(MSICOLUMNHASHENTRY));
1475         if (!hash_table)
1476             return ERROR_OUTOFMEMORY;
1477
1478         memset(hash_table, 0, MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*));
1479         tv->columns[col-1].hash_table = hash_table;
1480
1481         new_entry = (MSICOLUMNHASHENTRY *)(hash_table + MSITABLE_HASH_TABLE_SIZE);
1482
1483         for (i = 0; i < num_rows; i++, new_entry++)
1484         {
1485             UINT row_value, n;
1486             UINT offset = i + (tv->columns[col-1].offset/2) * num_rows;
1487             n = bytes_per_column( &tv->columns[col-1] );
1488             switch( n )
1489             {
1490             case 4:
1491                 offset = tv->columns[col-1].offset/2;
1492                 row_value = tv->table->data[i][offset] +
1493                     (tv->table->data[i][offset + 1] << 16);
1494                 break;
1495             case 2:
1496                 offset = tv->columns[col-1].offset/2;
1497                 row_value = tv->table->data[i][offset];
1498                 break;
1499             default:
1500                 ERR("oops! what is %d bytes per column?\n", n );
1501                 continue;
1502             }
1503
1504             new_entry->next = NULL;
1505             new_entry->value = row_value;
1506             new_entry->row = i;
1507             if (hash_table[row_value % MSITABLE_HASH_TABLE_SIZE])
1508             {
1509                 MSICOLUMNHASHENTRY *prev_entry = hash_table[row_value % MSITABLE_HASH_TABLE_SIZE];
1510                 while (prev_entry->next)
1511                     prev_entry = prev_entry->next;
1512                 prev_entry->next = new_entry;
1513             }
1514             else
1515                 hash_table[row_value % MSITABLE_HASH_TABLE_SIZE] = new_entry;
1516         }
1517     }
1518
1519     if( !*handle )
1520         entry = tv->columns[col-1].hash_table[val % MSITABLE_HASH_TABLE_SIZE];
1521     else
1522         entry = ((const MSICOLUMNHASHENTRY *)*handle)->next;
1523
1524     while (entry && entry->value != val)
1525         entry = entry->next;
1526
1527     *handle = (MSIITERHANDLE)entry;
1528     if (!entry)
1529         return ERROR_NO_MORE_ITEMS;
1530
1531     *row = entry->row;
1532     return ERROR_SUCCESS;
1533 }
1534
1535
1536 static const MSIVIEWOPS table_ops =
1537 {
1538     TABLE_fetch_int,
1539     TABLE_fetch_stream,
1540     TABLE_set_int,
1541     TABLE_insert_row,
1542     TABLE_execute,
1543     TABLE_close,
1544     TABLE_get_dimensions,
1545     TABLE_get_column_info,
1546     TABLE_modify,
1547     TABLE_delete,
1548     TABLE_find_matching_rows
1549 };
1550
1551 UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
1552 {
1553     MSITABLEVIEW *tv ;
1554     UINT r, sz, column_count;
1555     MSICOLUMNINFO *columns;
1556
1557     TRACE("%p %s %p\n", db, debugstr_w(name), view );
1558
1559     /* get the number of columns in this table */
1560     column_count = 0;
1561     r = get_tablecolumns( db, name, NULL, &column_count );
1562     if( r != ERROR_SUCCESS )
1563         return r;
1564
1565     /* if there's no columns, there's no table */
1566     if( column_count == 0 )
1567         return ERROR_INVALID_PARAMETER;
1568
1569     TRACE("Table found\n");
1570
1571     sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ;
1572     tv = msi_alloc_zero( sz );
1573     if( !tv )
1574         return ERROR_FUNCTION_FAILED;
1575
1576     columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO));
1577     if( !columns )
1578     {
1579         msi_free( tv );
1580         return ERROR_FUNCTION_FAILED;
1581     }
1582
1583     r = get_tablecolumns( db, name, columns, &column_count );
1584     if( r != ERROR_SUCCESS )
1585     {
1586         msi_free( columns );
1587         msi_free( tv );
1588         return ERROR_FUNCTION_FAILED;
1589     }
1590
1591     TRACE("Table has %d columns\n", column_count);
1592
1593     /* fill the structure */
1594     tv->view.ops = &table_ops;
1595     tv->db = db;
1596     tv->columns = columns;
1597     tv->num_cols = column_count;
1598     tv->table = NULL;
1599     tv->row_size = msi_table_get_row_size( columns, column_count );
1600
1601     TRACE("%s one row is %d bytes\n", debugstr_w(name), tv->row_size );
1602
1603     *view = (MSIVIEW*) tv;
1604     lstrcpyW( tv->name, name );
1605
1606     return ERROR_SUCCESS;
1607 }
1608
1609 UINT MSI_CommitTables( MSIDATABASE *db )
1610 {
1611     UINT r;
1612     MSITABLE *table = NULL;
1613
1614     TRACE("%p\n",db);
1615
1616     r = save_string_table( db );
1617     if( r != ERROR_SUCCESS )
1618     {
1619         WARN("failed to save string table r=%08x\n",r);
1620         return r;
1621     }
1622
1623     LIST_FOR_EACH_ENTRY( table, &db->tables, MSITABLE, entry )
1624     {
1625         r = save_table( db, table );
1626         if( r != ERROR_SUCCESS )
1627         {
1628             WARN("failed to save table %s (r=%08x)\n",
1629                   debugstr_w(table->name), r);
1630             return r;
1631         }
1632     }
1633
1634     /* force everything to reload next time */
1635     free_cached_tables( db );
1636
1637     return ERROR_SUCCESS;
1638 }
1639
1640 MSICONDITION MSI_DatabaseIsTablePersistent( MSIDATABASE *db, LPCWSTR table )
1641 {
1642     if (!table)
1643         return MSICONDITION_ERROR;
1644
1645     return MSICONDITION_FALSE;
1646 }
1647
1648 static MSIRECORD *msi_get_transform_record( MSITABLEVIEW *tv, string_table *st, USHORT *rawdata )
1649 {
1650     UINT i, val, ofs = 0;
1651     USHORT mask = *rawdata++;
1652     MSICOLUMNINFO *columns = tv->columns;
1653     MSIRECORD *rec;
1654
1655     rec = MSI_CreateRecord( tv->num_cols );
1656     if( !rec )
1657         return rec;
1658
1659     TRACE("row -> \n");
1660     for( i=0; i<tv->num_cols; i++ )
1661     {
1662         UINT n = bytes_per_column( &columns[i] );
1663
1664         if ( (mask&1) && (i>=(mask>>8)) )
1665             break;
1666         /* all keys must be present */
1667         if ( (~mask&1) && (~columns[i].type & MSITYPE_KEY) && ((1<<i) & ~mask) )
1668             continue;
1669
1670         switch( n )
1671         {
1672         case 2:
1673             val = rawdata[ofs];
1674             if( (columns[i].type & MSITYPE_STRING) &&
1675                 ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1676             {
1677                 LPCWSTR sval = msi_string_lookup_id( st, val );
1678                 MSI_RecordSetStringW( rec, i+1, sval );
1679                 TRACE(" field %d [%s]\n", i+1, debugstr_w(sval));
1680             }
1681             else
1682             {
1683                 if (val)
1684                     MSI_RecordSetInteger( rec, i+1, val^0x8000 );
1685                 TRACE(" field %d [0x%04x]\n", i+1, val );
1686             }
1687             break;
1688         case 4:
1689             val = (rawdata[ofs] + (rawdata[ofs + 1]<<16));
1690             if (val)
1691                 MSI_RecordSetInteger( rec, i+1, val^0x80000000 );
1692             TRACE(" field %d [0x%08x]\n", i+1, val );
1693             break;
1694         default:
1695             ERR("oops - unknown column width %d\n", n);
1696             break;
1697         }
1698         ofs += n/2;
1699     }
1700     return rec;
1701 }
1702
1703 static void dump_record( MSIRECORD *rec )
1704 {
1705     UINT i, n;
1706
1707     n = MSI_RecordGetFieldCount( rec );
1708     for( i=1; i<=n; i++ )
1709     {
1710         LPCWSTR sval = MSI_RecordGetString( rec, i );
1711
1712         if( MSI_RecordIsNull( rec, i ) )
1713             TRACE("row -> []\n");
1714         else if( (sval = MSI_RecordGetString( rec, i )) )
1715             TRACE("row -> [%s]\n", debugstr_w(sval));
1716         else
1717             TRACE("row -> [0x%08x]\n", MSI_RecordGetInteger( rec, i ) );
1718     }
1719 }
1720
1721 static void dump_table( string_table *st, USHORT *rawdata, UINT rawsize )
1722 {
1723     LPCWSTR sval;
1724     UINT i;
1725
1726     for( i=0; i<(rawsize/2); i++ )
1727     {
1728         sval = msi_string_lookup_id( st, rawdata[i] );
1729         MESSAGE(" %04x %s\n", rawdata[i], debugstr_w(sval) );
1730     }
1731 }
1732
1733 static UINT* msi_record_to_row( MSITABLEVIEW *tv, MSIRECORD *rec )
1734 {
1735     LPCWSTR str;
1736     UINT i, r, *data;
1737
1738     data = msi_alloc( tv->num_cols *sizeof (UINT) );
1739     for( i=0; i<tv->num_cols; i++ )
1740     {
1741         data[i] = 0;
1742
1743         if ( ~tv->columns[i].type & MSITYPE_KEY )
1744             continue;
1745
1746         /* turn the transform column value into a row value */
1747         if ( ( tv->columns[i].type & MSITYPE_STRING ) &&
1748              ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1749         {
1750             str = MSI_RecordGetString( rec, i+1 );
1751             r = msi_string2idW( tv->db->strings, str, &data[i] );
1752
1753             /* if there's no matching string in the string table,
1754                these keys can't match any record, so fail now. */
1755             if( ERROR_SUCCESS != r )
1756             {
1757                 msi_free( data );
1758                 return NULL;
1759             }
1760         }
1761         else
1762             data[i] = MSI_RecordGetInteger( rec, i+1 );
1763     }
1764     return data;
1765 }
1766
1767 static UINT msi_row_matches( MSITABLEVIEW *tv, UINT row, UINT *data )
1768 {
1769     UINT i, r, x, ret = ERROR_FUNCTION_FAILED;
1770
1771     for( i=0; i<tv->num_cols; i++ )
1772     {
1773         if ( ~tv->columns[i].type & MSITYPE_KEY )
1774             continue;
1775
1776         /* turn the transform column value into a row value */
1777         r = TABLE_fetch_int( &tv->view, row, i+1, &x );
1778         if ( r != ERROR_SUCCESS )
1779         {
1780             ERR("TABLE_fetch_int shouldn't fail here\n");
1781             break;
1782         }
1783
1784         /* if this key matches, move to the next column */
1785         if ( x != data[i] )
1786         {
1787             ret = ERROR_FUNCTION_FAILED;
1788             break;
1789         }
1790
1791         ret = ERROR_SUCCESS;
1792     }
1793
1794     return ret;
1795 }
1796
1797 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row )
1798 {
1799     UINT i, r = ERROR_FUNCTION_FAILED, *data;
1800
1801     data = msi_record_to_row( tv, rec );
1802     if( !data )
1803         return r;
1804     for( i=0; i<tv->table->row_count; i++ )
1805     {
1806         r = msi_row_matches( tv, i, data );
1807         if( r == ERROR_SUCCESS )
1808         {
1809             *row = i;
1810             break;
1811         }
1812     }
1813     msi_free( data );
1814     return r;
1815 }
1816
1817 static UINT msi_delete_row( MSITABLEVIEW *tv, UINT row )
1818 {
1819     UINT i;
1820     for( i=1; i<=tv->num_cols; i++ )
1821         tv->view.ops->set_int( &tv->view, row, i, 0 );
1822     return ERROR_SUCCESS;
1823 }
1824
1825 static UINT msi_table_load_transform( MSIDATABASE *db, IStorage *stg,
1826                                       string_table *st, LPCWSTR name )
1827 {
1828     UINT rawsize = 0;
1829     USHORT *rawdata = NULL;
1830     MSITABLEVIEW *tv = NULL;
1831     UINT r, n, sz, i, mask;
1832     MSIRECORD *rec = NULL;
1833     UINT colcol = 0;
1834
1835     TRACE("%p %p %p %s\n", db, stg, st, debugstr_w(name) );
1836
1837     /* read the transform data */
1838     read_stream_data( stg, name, &rawdata, &rawsize );
1839     if ( !rawdata )
1840     {
1841         TRACE("table %s empty\n", debugstr_w(name) );
1842         return ERROR_INVALID_TABLE;
1843     }
1844
1845     /* create a table view */
1846     r = TABLE_CreateView( db, name, (MSIVIEW**) &tv );
1847     if( r != ERROR_SUCCESS )
1848         goto err;
1849
1850     r = tv->view.ops->execute( &tv->view, NULL );
1851     if( r != ERROR_SUCCESS )
1852         goto err;
1853
1854     TRACE("name = %s columns = %u row_size = %u raw size = %u\n",
1855           debugstr_w(name), tv->num_cols, tv->row_size, rawsize );
1856
1857     /* interpret the data */
1858     r = ERROR_SUCCESS;
1859     for( n=0; n < (rawsize/2);  )
1860     {
1861         mask = rawdata[n];
1862
1863         if (mask&1)
1864         {
1865             /*
1866              * if the low bit is set, columns are continuous and
1867              * the number of columns is specified in the high byte
1868              */
1869             sz = 2 + tv->row_size;
1870         }
1871         else
1872         {
1873             /*
1874              * If the low bit is not set, rowdata[n] is a bitmask.
1875              * Excepting for key fields, which are always present,
1876              *  each bit indicates that a field is present in the transform record.
1877              *
1878              * rawdata[n] == 0 is a special case ... only the keys will be present
1879              * and it means that this row should be deleted.
1880              */
1881             sz = 2;
1882             for( i=0; i<tv->num_cols; i++ )
1883             {
1884                 if( (tv->columns[i].type & MSITYPE_KEY) || ((1<<i)&mask))
1885                     sz += bytes_per_column( &tv->columns[i] );
1886             }
1887         }
1888
1889         /* check we didn't run of the end of the table */
1890         if ( (n+sz) > rawsize )
1891         {
1892             ERR("borked.\n");
1893             dump_table( st, rawdata, rawsize );
1894             break;
1895         }
1896
1897         rec = msi_get_transform_record( tv, st, &rawdata[n] );
1898         if (rec)
1899         {
1900             UINT row = 0;
1901
1902             r = msi_table_find_row( tv, rec, &row );
1903
1904             if( rawdata[n] & 1)
1905             {
1906                 TRACE("insert [%d]: \n", row);
1907
1908                 /*
1909                  * Native msi seems writes nul into the
1910                  * Number (2nd) column of the _Columns table.
1911                  * Not sure that it's deliberate...
1912                  */
1913                 if (!lstrcmpW(name, szColumns))
1914                 {
1915                     if ( MSI_RecordIsNull( rec, 2 ) )
1916                         MSI_RecordSetInteger( rec, 2, ++colcol );
1917                     else
1918                         ERR("_Columns has non-null data...\n");
1919                 }
1920
1921                 TABLE_insert_row( &tv->view, rec );
1922             }
1923             else if( mask & 0xff )
1924             {
1925                 TRACE("modify [%d]: \n", row);
1926                 msi_table_modify_row( tv, rec, row, mask );
1927             }
1928             else
1929             {
1930                 TRACE("delete [%d]: \n", row);
1931                 msi_delete_row( tv, row );
1932             }
1933             if( TRACE_ON(msidb) ) dump_record( rec );
1934             msiobj_release( &rec->hdr );
1935         }
1936
1937         n += sz/2;
1938
1939     }
1940
1941 err:
1942     /* no need to free the table, it's associated with the database */
1943     msi_free( rawdata );
1944     if( tv )
1945         tv->view.ops->delete( &tv->view );
1946
1947     return ERROR_SUCCESS;
1948 }
1949
1950 /*
1951  * msi_table_apply_transform
1952  *
1953  * Enumerate the table transforms in a transform storage and apply each one.
1954  */
1955 UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
1956 {
1957     IEnumSTATSTG *stgenum = NULL;
1958     HRESULT r;
1959     STATSTG stat;
1960     ULONG count;
1961     WCHAR name[0x40];
1962     string_table *strings;
1963     UINT ret = ERROR_FUNCTION_FAILED;
1964
1965     TRACE("%p %p\n", db, stg );
1966
1967     strings = load_string_table( stg );
1968     if( !strings )
1969         goto end;
1970
1971     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
1972     if( FAILED( r ) )
1973         goto end;
1974
1975     /*
1976      * Apply _Tables and _Coluimns transforms first so that
1977      * the table metadata is correct, and empty tables exist.
1978      */
1979     ret = msi_table_load_transform( db, stg, strings, szTables );
1980     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
1981         goto end;
1982
1983     ret = msi_table_load_transform( db, stg, strings, szColumns );
1984     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
1985         goto end;
1986
1987     ret = ERROR_SUCCESS;
1988
1989     while( r == ERROR_SUCCESS )
1990     {
1991         count = 0;
1992         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
1993         if( FAILED( r ) || !count )
1994             break;
1995
1996         decode_streamname( stat.pwcsName, name );
1997         if ( name[0] != 0x4840 )
1998             continue;
1999
2000         TRACE("transform contains stream %s\n", debugstr_w(name));
2001
2002         if ( !lstrcmpW( name+1, szStringPool ) ||
2003              !lstrcmpW( name+1, szStringData ) ||
2004              !lstrcmpW( name+1, szColumns ) ||
2005              !lstrcmpW( name+1, szTables ) )
2006             continue;
2007
2008         ret = msi_table_load_transform( db, stg, strings, name+1 );
2009     }
2010
2011     if ( ret == ERROR_SUCCESS )
2012     {
2013         MSITRANSFORM *t;
2014
2015         t = msi_alloc( sizeof *t );
2016         t->stg = stg;
2017         IStorage_AddRef( stg );
2018         list_add_tail( &db->transforms, &t->entry );
2019     }
2020
2021 end:
2022     if ( stgenum )
2023         IEnumSTATSTG_Release( stgenum );
2024     if ( strings )
2025         msi_destroy_stringtable( strings );
2026
2027     return ret;
2028 }
2029
2030 void msi_free_transforms( MSIDATABASE *db )
2031 {
2032     while( !list_empty( &db->transforms ) )
2033     {
2034         MSITRANSFORM *t = LIST_ENTRY( list_head( &db->transforms ),
2035                                       MSITRANSFORM, entry );
2036         list_remove( &t->entry );
2037         IStorage_Release( t->stg );
2038         msi_free( t );
2039     }
2040 }