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