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 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 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     if (sz)
 416     {
 417         r = IStream_Write(stm, data, sz, &count );
 418         if( FAILED( r ) || ( count != sz ) )
 419         {
 420             WARN("Failed to Write\n");
 421             goto end;
 422         }
 423     }
 424
 425     ret = ERROR_SUCCESS;
 426
 427 end:
 428     IStream_Release( stm );
 429
 430     return ret;
 431 }
 432
 433 static void free_table( MSITABLE *table )
 434 {
 435     int i;
 436     for( i=0; i<table->row_count; i++ )
 437         msi_free( table->data[i] );
 438     msi_free( table->data );
 439     msi_free( table );
 440 }
 441
 442 static UINT msi_table_get_row_size( const MSICOLUMNINFO *cols, UINT count )
 443 {
 444     const MSICOLUMNINFO *last_col = &cols[count-1];
 445     if (!count)
 446         return 0;
 447     return last_col->offset + bytes_per_column( last_col );
 448 }
 449
 450 /* add this table to the list of cached tables in the database */
 451 static MSITABLE *read_table_from_storage( IStorage *stg, LPCWSTR name,
 452                                     const MSICOLUMNINFO *cols, UINT num_cols )
 453 {
 454     MSITABLE *t;
 455     USHORT *rawdata = NULL;
 456     UINT rawsize = 0, i, j, row_size = 0;
 457
 458     TRACE("%s\n",debugstr_w(name));
 459
 460     /* nonexistent tables should be interpreted as empty tables */
 461     t = msi_alloc( sizeof (MSITABLE) + lstrlenW(name)*sizeof (WCHAR) );
 462     if( !t )
 463         return t;
 464
 465     row_size = msi_table_get_row_size( cols, num_cols );
 466
 467     t->row_count = 0;
 468     t->data = NULL;
 469     lstrcpyW( t->name, name );
 470
 471     /* if we can't read the table, just assume that it's empty */
 472     read_stream_data( stg, name, &rawdata, &rawsize );
 473     if( !rawdata )
 474         return t;
 475
 476     TRACE("Read %d bytes\n", rawsize );
 477
 478     if( rawsize % row_size )
 479     {
 480         WARN("Table size is invalid %d/%d\n", rawsize, row_size );
 481         goto err;
 482     }
 483
 484     t->row_count = rawsize / row_size;
 485     t->data = msi_alloc_zero( t->row_count * sizeof (USHORT*) );
 486     if( !t->data )
 487         goto err;
 488
 489     /* transpose all the data */
 490     TRACE("Transposing data from %d rows\n", t->row_count );
 491     for( i=0; i<t->row_count; i++ )
 492     {
 493         t->data[i] = msi_alloc( row_size );
 494         if( !t->data[i] )
 495             goto err;
 496
 497         for( j=0; j<num_cols; j++ )
 498         {
 499             UINT ofs = cols[j].offset/2;
 500             UINT n = bytes_per_column( &cols[j] );
 501
 502             switch( n )
 503             {
 504             case 2:
 505                 t->data[i][ofs] = rawdata[ofs*t->row_count + i ];
 506                 break;
 507             case 4:
 508                 t->data[i][ofs] = rawdata[ofs*t->row_count + i*2 ];
 509                 t->data[i][ofs+1] = rawdata[ofs*t->row_count + i*2 + 1];
 510                 break;
 511             default:
 512                 ERR("oops - unknown column width %d\n", n);
 513                 goto err;
 514             }
 515         }
 516     }
 517
 518     msi_free( rawdata );
 519     return t;
 520 err:
 521     msi_free( rawdata );
 522     free_table( t );
 523     return NULL;
 524 }
 525
 526 void free_cached_tables( MSIDATABASE *db )
 527 {
 528     while( !list_empty( &db->tables ) )
 529     {
 530         MSITABLE *t = LIST_ENTRY( list_head( &db->tables ), MSITABLE, entry );
 531
 532         list_remove( &t->entry );
 533         free_table( t );
 534     }
 535 }
 536
 537 static MSITABLE *find_cached_table( MSIDATABASE *db, LPCWSTR name )
 538 {
 539     MSITABLE *t;
 540
 541     LIST_FOR_EACH_ENTRY( t, &db->tables, MSITABLE, entry )
 542         if( !lstrcmpW( name, t->name ) )
 543             return t;
 544
 545     return NULL;
 546 }
 547
 548 static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name, MSICOLUMNINFO **pcols, UINT *pcount )
 549 {
 550     UINT r, column_count = 0;
 551     MSICOLUMNINFO *columns;
 552
 553     /* get the number of columns in this table */
 554     column_count = 0;
 555     r = get_tablecolumns( db, name, NULL, &column_count );
 556     if( r != ERROR_SUCCESS )
 557         return r;
 558
 559     /* if there's no columns, there's no table */
 560     if( column_count == 0 )
 561         return ERROR_INVALID_PARAMETER;
 562
 563     TRACE("Table %s found\n", debugstr_w(name) );
 564
 565     columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO) );
 566     if( !columns )
 567         return ERROR_FUNCTION_FAILED;
 568
 569     r = get_tablecolumns( db, name, columns, &column_count );
 570     if( r != ERROR_SUCCESS )
 571     {
 572         msi_free( columns );
 573         return ERROR_FUNCTION_FAILED;
 574     }
 575
 576     *pcols = columns;
 577     *pcount = column_count;
 578
 579     return r;
 580 }
 581
 582 static MSITABLE *get_table( MSIDATABASE *db, LPCWSTR name,
 583                             const MSICOLUMNINFO *cols, UINT num_cols )
 584 {
 585     MSITABLE *table;
 586
 587     /* first, see if the table is cached */
 588     table = find_cached_table( db, name );
 589     if( table )
 590         return table;
 591
 592     table = read_table_from_storage( db->storage, name, cols, num_cols );
 593     if( table )
 594         list_add_head( &db->tables, &table->entry );
 595
 596     return table;
 597 }
 598
 599 static UINT save_table( MSIDATABASE *db, MSITABLE *t )
 600 {
 601     USHORT *rawdata = NULL, *p;
 602     UINT rawsize, r, i, j, row_size, num_cols = 0;
 603     MSICOLUMNINFO *cols = NULL;
 604
 605     TRACE("Saving %s\n", debugstr_w( t->name ) );
 606
 607     r = table_get_column_info( db, t->name, &cols, &num_cols );
 608     if( r != ERROR_SUCCESS )
 609         return r;
 610
 611     row_size = msi_table_get_row_size( cols, num_cols );
 612
 613     rawsize = t->row_count * row_size;
 614     rawdata = msi_alloc_zero( rawsize );
 615     if( !rawdata )
 616     {
 617         r = ERROR_NOT_ENOUGH_MEMORY;
 618         goto err;
 619     }
 620
 621     p = rawdata;
 622     for( i=0; i<num_cols; i++ )
 623     {
 624         for( j=0; j<t->row_count; j++ )
 625         {
 626             UINT offset = cols[i].offset;
 627
 628             *p++ = t->data[j][offset/2];
 629             if( 4 == bytes_per_column( &cols[i] ) )
 630                 *p++ = t->data[j][offset/2+1];
 631         }
 632     }
 633
 634     TRACE("writing %d bytes\n", rawsize);
 635     r = write_stream_data( db->storage, t->name, rawdata, rawsize );
 636
 637 err:
 638     msi_free_colinfo( cols, num_cols );
 639     msi_free( cols );
 640     msi_free( rawdata );
 641
 642     return r;
 643 }
 644
 645 /* information for default tables */
 646 static const WCHAR szTables[]  = { '_','T','a','b','l','e','s',0 };
 647 static const WCHAR szTable[]  = { 'T','a','b','l','e',0 };
 648 static const WCHAR szName[]    = { 'N','a','m','e',0 };
 649 static const WCHAR szColumns[] = { '_','C','o','l','u','m','n','s',0 };
 650 static const WCHAR szNumber[]  = { 'N','u','m','b','e','r',0 };
 651 static const WCHAR szType[]    = { 'T','y','p','e',0 };
 652
 653 static const MSICOLUMNINFO _Columns_cols[4] = {
 654     { szColumns, 1, szTable,  MSITYPE_VALID | MSITYPE_STRING | 64, 0 },
 655     { szColumns, 2, szNumber, MSITYPE_VALID | 2,                   2 },
 656     { szColumns, 3, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 4 },
 657     { szColumns, 4, szType,   MSITYPE_VALID | 2,                   6 },
 658 };
 659 static const MSICOLUMNINFO _Tables_cols[1] = {
 660     { szTables,  1, szName,   MSITYPE_VALID | MSITYPE_STRING | 64, 0 },
 661 };
 662
 663 static void table_calc_column_offsets( MSICOLUMNINFO *colinfo, DWORD count )
 664 {
 665     DWORD i;
 666
 667     for( i=0; colinfo && (i<count); i++ )
 668     {
 669          assert( (i+1) == colinfo[ i ].number );
 670          if (i)
 671              colinfo[i].offset = colinfo[ i - 1 ].offset
 672                                + bytes_per_column( &colinfo[ i - 1 ] );
 673          else
 674              colinfo[i].offset = 0;
 675          TRACE("column %d is [%s] with type %08x ofs %d\n",
 676                colinfo[i].number, debugstr_w(colinfo[i].colname),
 677                colinfo[i].type, colinfo[i].offset);
 678     }
 679 }
 680
 681 static UINT get_defaulttablecolumns( LPCWSTR name, MSICOLUMNINFO *colinfo, UINT *sz)
 682 {
 683     const MSICOLUMNINFO *p;
 684     DWORD i, n;
 685
 686     TRACE("%s\n", debugstr_w(name));
 687
 688     if (!lstrcmpW( name, szTables ))
 689     {
 690         p = _Tables_cols;
 691         n = 1;
 692     }
 693     else if (!lstrcmpW( name, szColumns ))
 694     {
 695         p = _Columns_cols;
 696         n = 4;
 697     }
 698     else
 699         return ERROR_FUNCTION_FAILED;
 700
 701     /* duplicate the string data so we can free it in msi_free_colinfo */
 702     for (i=0; i<n; i++)
 703     {
 704         if (colinfo && (i < *sz) )
 705         {
 706             memcpy( &colinfo[i], &p[i], sizeof(MSICOLUMNINFO) );
 707             colinfo[i].tablename = strdupW( p[i].tablename );
 708             colinfo[i].colname = strdupW( p[i].colname );
 709         }
 710         if( colinfo && (i >= *sz) )
 711             break;
 712     }
 713     table_calc_column_offsets( colinfo, n );
 714     *sz = n;
 715     return ERROR_SUCCESS;
 716 }
 717
 718 static void msi_free_colinfo( MSICOLUMNINFO *colinfo, UINT count )
 719 {
 720     UINT i;
 721
 722     for( i=0; i<count; i++ )
 723     {
 724         msi_free( (LPWSTR) colinfo[i].tablename );
 725         msi_free( (LPWSTR) colinfo[i].colname );
 726         msi_free( colinfo[i].hash_table );
 727     }
 728 }
 729
 730 static LPWSTR msi_makestring( MSIDATABASE *db, UINT stringid)
 731 {
 732     return strdupW(msi_string_lookup_id( db->strings, stringid ));
 733 }
 734
 735 static UINT get_tablecolumns( MSIDATABASE *db,
 736        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz)
 737 {
 738     UINT r, i, n=0, table_id, count, maxcount = *sz;
 739     MSITABLE *table = NULL;
 740
 741     TRACE("%s\n", debugstr_w(szTableName));
 742
 743     /* first check if there is a default table with that name */
 744     r = get_defaulttablecolumns( szTableName, colinfo, sz );
 745     if( ( r == ERROR_SUCCESS ) && *sz )
 746         return r;
 747
 748     table = get_table( db, szColumns, _Columns_cols, 4 );
 749     if( !table )
 750     {
 751         ERR("couldn't load _Columns table\n");
 752         return ERROR_FUNCTION_FAILED;
 753     }
 754
 755     /* convert table and column names to IDs from the string table */
 756     r = msi_string2idW( db->strings, szTableName, &table_id );
 757     if( r != ERROR_SUCCESS )
 758     {
 759         WARN("Couldn't find id for %s\n", debugstr_w(szTableName));
 760         return r;
 761     }
 762
 763     TRACE("Table id is %d, row count is %d\n", table_id, table->row_count);
 764
 765     /* if maxcount is non-zero, assume it's exactly right for this table */
 766     memset( colinfo, 0, maxcount*sizeof(*colinfo) );
 767     count = table->row_count;
 768     for( i=0; i<count; i++ )
 769     {
 770         if( table->data[ i ][ 0 ] != table_id )
 771             continue;
 772         if( colinfo )
 773         {
 774             UINT id = table->data[ i ] [ 2 ];
 775             UINT col = table->data[ i ][ 1 ] - (1<<15);
 776
 777             /* check the column number is in range */
 778             if (col<1 || col>maxcount)
 779             {
 780                 ERR("column %d out of range\n", col);
 781                 continue;
 782             }
 783
 784             /* check if this column was already set */
 785             if (colinfo[ col - 1 ].number)
 786             {
 787                 ERR("duplicate column %d\n", col);
 788                 continue;
 789             }
 790
 791             colinfo[ col - 1 ].tablename = msi_makestring( db, table_id );
 792             colinfo[ col - 1 ].number = col;
 793             colinfo[ col - 1 ].colname = msi_makestring( db, id );
 794             colinfo[ col - 1 ].type = table->data[ i ] [ 3 ] - (1<<15);
 795             colinfo[ col - 1 ].offset = 0;
 796             colinfo[ col - 1 ].hash_table = NULL;
 797         }
 798         n++;
 799     }
 800
 801     TRACE("%s has %d columns\n", debugstr_w(szTableName), n);
 802
 803     if (colinfo && n != maxcount)
 804     {
 805         ERR("missing column in table %s\n", debugstr_w(szTableName));
 806         msi_free_colinfo(colinfo, maxcount );
 807         return ERROR_FUNCTION_FAILED;
 808     }
 809
 810     table_calc_column_offsets( colinfo, n );
 811     *sz = n;
 812
 813     return ERROR_SUCCESS;
 814 }
 815
 816 /* try to find the table name in the _Tables table */
 817 BOOL TABLE_Exists( MSIDATABASE *db, LPCWSTR name )
 818 {
 819     UINT r, table_id = 0, i, count;
 820     MSITABLE *table = NULL;
 821
 822     if( !lstrcmpW( name, szTables ) )
 823         return TRUE;
 824     if( !lstrcmpW( name, szColumns ) )
 825         return TRUE;
 826
 827     r = msi_string2idW( db->strings, name, &table_id );
 828     if( r != ERROR_SUCCESS )
 829     {
 830         TRACE("Couldn't find id for %s\n", debugstr_w(name));
 831         return FALSE;
 832     }
 833
 834     table = get_table( db, szTables, _Tables_cols, 1 );
 835     if( !table )
 836     {
 837         TRACE("table %s not available\n", debugstr_w(szTables));
 838         return FALSE;
 839     }
 840
 841     /* count = table->size/2; */
 842     count = table->row_count;
 843     for( i=0; i<count; i++ )
 844         if( table->data[ i ][ 0 ] == table_id )
 845             break;
 846
 847     if (i!=count)
 848         return TRUE;
 849
 850     TRACE("Searched %d tables, but %d was not found\n", count, table_id );
 851
 852     return FALSE;
 853 }
 854
 855 /* below is the query interface to a table */
 856
 857 typedef struct tagMSITABLEVIEW
 858 {
 859     MSIVIEW        view;
 860     MSIDATABASE   *db;
 861     MSITABLE      *table;
 862     MSICOLUMNINFO *columns;
 863     UINT           num_cols;
 864     UINT           row_size;
 865     WCHAR          name[1];
 866 } MSITABLEVIEW;
 867
 868 static UINT TABLE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
 869 {
 870     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
 871     UINT offset, num_rows, n;
 872
 873     if( !tv->table )
 874         return ERROR_INVALID_PARAMETER;
 875
 876     if( (col==0) || (col>tv->num_cols) )
 877         return ERROR_INVALID_PARAMETER;
 878
 879     /* how many rows are there ? */
 880     num_rows = tv->table->row_count;
 881     if( row >= num_rows )
 882         return ERROR_NO_MORE_ITEMS;
 883
 884     if( tv->columns[col-1].offset >= tv->row_size )
 885     {
 886         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
 887         ERR("%p %p\n", tv, tv->columns );
 888         return ERROR_FUNCTION_FAILED;
 889     }
 890
 891     offset = row + (tv->columns[col-1].offset/2) * num_rows;
 892     n = bytes_per_column( &tv->columns[col-1] );
 893     switch( n )
 894     {
 895     case 4:
 896         offset = tv->columns[col-1].offset/2;
 897         *val = tv->table->data[row][offset] +
 898                (tv->table->data[row][offset + 1] << 16);
 899         break;
 900     case 2:
 901         offset = tv->columns[col-1].offset/2;
 902         *val = tv->table->data[row][offset];
 903         break;
 904     default:
 905         ERR("oops! what is %d bytes per column?\n", n );
 906         return ERROR_FUNCTION_FAILED;
 907     }
 908
 909     /* TRACE("Data [%d][%d] = %d\n", row, col, *val ); */
 910
 911     return ERROR_SUCCESS;
 912 }
 913
 914 /*
 915  * We need a special case for streams, as we need to reference column with
 916  * the name of the stream in the same table, and the table name
 917  * which may not be available at higher levels of the query
 918  */
 919 static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
 920 {
 921     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
 922     UINT ival = 0, refcol = 0, r;
 923     LPCWSTR sval;
 924     LPWSTR full_name;
 925     DWORD len;
 926     static const WCHAR szDot[] = { '.', 0 };
 927     WCHAR number[0x20];
 928
 929     if( !view->ops->fetch_int )
 930         return ERROR_INVALID_PARAMETER;
 931
 932     /*
 933      * The column marked with the type stream data seems to have a single number
 934      * which references the column containing the name of the stream data
 935      *
 936      * Fetch the column to reference first.
 937      */
 938     r = view->ops->fetch_int( view, row, col, &ival );
 939     if( r != ERROR_SUCCESS )
 940         return r;
 941
 942     /* check the column value is in range */
 943     if (ival < 0 || ival > tv->num_cols || ival == col)
 944     {
 945         ERR("bad column ref (%u) for stream\n", ival);
 946         return ERROR_FUNCTION_FAILED;
 947     }
 948
 949     if ( tv->columns[ival - 1].type & MSITYPE_STRING )
 950     {
 951         /* now get the column with the name of the stream */
 952         r = view->ops->fetch_int( view, row, ival, &refcol );
 953         if ( r != ERROR_SUCCESS )
 954             return r;
 955
 956         /* lookup the string value from the string table */
 957         sval = msi_string_lookup_id( tv->db->strings, refcol );
 958         if ( !sval )
 959             return ERROR_INVALID_PARAMETER;
 960     }
 961     else
 962     {
 963         static const WCHAR fmt[] = { '%','d',0 };
 964         sprintfW( number, fmt, ival );
 965         sval = number;
 966     }
 967
 968     len = lstrlenW( tv->name ) + 2 + lstrlenW( sval );
 969     full_name = msi_alloc( len*sizeof(WCHAR) );
 970     lstrcpyW( full_name, tv->name );
 971     lstrcatW( full_name, szDot );
 972     lstrcatW( full_name, sval );
 973
 974     r = db_get_raw_stream( tv->db, full_name, stm );
 975     if( r )
 976         ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r);
 977     msi_free( full_name );
 978
 979     return r;
 980 }
 981
 982 static UINT TABLE_set_int( MSITABLEVIEW *tv, UINT row, UINT col, UINT val )
 983 {
 984     UINT offset, n;
 985
 986     if( !tv->table )
 987         return ERROR_INVALID_PARAMETER;
 988
 989     if( (col==0) || (col>tv->num_cols) )
 990         return ERROR_INVALID_PARAMETER;
 991
 992     if( tv->columns[col-1].offset >= tv->row_size )
 993     {
 994         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
 995         ERR("%p %p\n", tv, tv->columns );
 996         return ERROR_FUNCTION_FAILED;
 997     }
 998
 999     msi_free( tv->columns[col-1].hash_table );
1000     tv->columns[col-1].hash_table = NULL;
1001
1002     n = bytes_per_column( &tv->columns[col-1] );
1003     switch( n )
1004     {
1005     case 4:
1006         offset = tv->columns[col-1].offset/2;
1007         tv->table->data[row][offset]     = val & 0xffff;
1008         tv->table->data[row][offset + 1] = (val>>16)&0xffff;
1009         break;
1010     case 2:
1011         offset = tv->columns[col-1].offset/2;
1012         tv->table->data[row][offset] = val;
1013         break;
1014     default:
1015         ERR("oops! what is %d bytes per column?\n", n );
1016         return ERROR_FUNCTION_FAILED;
1017     }
1018     return ERROR_SUCCESS;
1019 }
1020
1021 static UINT TABLE_set_row( struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask )
1022 {
1023     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1024     UINT i, val, r = ERROR_SUCCESS;
1025
1026     if ( !tv->table )
1027         return ERROR_INVALID_PARAMETER;
1028
1029     /* test if any of the mask bits are invalid */
1030     if ( mask >= (1<<tv->num_cols) )
1031         return ERROR_INVALID_PARAMETER;
1032
1033     for ( i = 0; i < tv->num_cols; i++ )
1034     {
1035         /* only update the fields specified in the mask */
1036         if ( !(mask&(1<<i)) )
1037             continue;
1038
1039         /* FIXME: should we allow updating keys? */
1040
1041         val = 0;
1042         if ( !MSI_RecordIsNull( rec, i + 1 ) )
1043         {
1044             if ( MSITYPE_IS_BINARY(tv->columns[ i ].type) )
1045             {
1046                 val = 1; /* refers to the first key column */
1047             }
1048             else if ( tv->columns[i].type & MSITYPE_STRING )
1049             {
1050                 LPCWSTR sval = MSI_RecordGetString( rec, i + 1 );
1051                 val = msi_addstringW( tv->db->strings, 0, sval, -1, 1, StringPersistent );
1052             }
1053             else if ( 2 == bytes_per_column( &tv->columns[ i ] ) )
1054             {
1055                 val = 0x8000 + MSI_RecordGetInteger( rec, i + 1 );
1056                 if ( val & 0xffff0000 )
1057                 {
1058                     ERR("field %u value %d out of range\n", i+1, val - 0x8000 );
1059                     return ERROR_FUNCTION_FAILED;
1060                 }
1061             }
1062             else
1063             {
1064                 INT ival = MSI_RecordGetInteger( rec, i + 1 );
1065                 val = ival ^ 0x80000000;
1066             }
1067         }
1068
1069         r = TABLE_set_int( tv, row, i+1, val );
1070         if ( r != ERROR_SUCCESS )
1071             break;
1072     }
1073     return r;
1074 }
1075
1076 static UINT table_create_new_row( struct tagMSIVIEW *view, UINT *num )
1077 {
1078     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1079     USHORT **p, *row;
1080     UINT sz;
1081
1082     TRACE("%p\n", view);
1083
1084     if( !tv->table )
1085         return ERROR_INVALID_PARAMETER;
1086
1087     row = msi_alloc_zero( tv->row_size );
1088     if( !row )
1089         return ERROR_NOT_ENOUGH_MEMORY;
1090
1091     sz = (tv->table->row_count + 1) * sizeof (UINT*);
1092     if( tv->table->data )
1093         p = msi_realloc( tv->table->data, sz );
1094     else
1095         p = msi_alloc( sz );
1096     if( !p )
1097     {
1098         msi_free( row );
1099         return ERROR_NOT_ENOUGH_MEMORY;
1100     }
1101
1102     tv->table->data = p;
1103     tv->table->data[tv->table->row_count] = row;
1104     *num = tv->table->row_count;
1105     tv->table->row_count++;
1106
1107     return ERROR_SUCCESS;
1108 }
1109
1110 static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
1111 {
1112     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1113
1114     TRACE("%p %p\n", tv, record);
1115
1116     TRACE("There are %d columns\n", tv->num_cols );
1117     tv->table = get_table( tv->db, tv->name, tv->columns, tv->num_cols );
1118     if( !tv->table )
1119         return ERROR_FUNCTION_FAILED;
1120
1121     return ERROR_SUCCESS;
1122 }
1123
1124 static UINT TABLE_close( struct tagMSIVIEW *view )
1125 {
1126     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1127
1128     TRACE("%p\n", view );
1129
1130     if( !tv->table )
1131         return ERROR_FUNCTION_FAILED;
1132
1133     tv->table = NULL;
1134
1135     return ERROR_SUCCESS;
1136 }
1137
1138 static UINT TABLE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols)
1139 {
1140     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1141
1142     TRACE("%p %p %p\n", view, rows, cols );
1143
1144     if( cols )
1145         *cols = tv->num_cols;
1146     if( rows )
1147     {
1148         if( !tv->table )
1149             return ERROR_INVALID_PARAMETER;
1150         *rows = tv->table->row_count;
1151     }
1152
1153     return ERROR_SUCCESS;
1154 }
1155
1156 static UINT TABLE_get_column_info( struct tagMSIVIEW *view,
1157                 UINT n, LPWSTR *name, UINT *type )
1158 {
1159     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1160
1161     TRACE("%p %d %p %p\n", tv, n, name, type );
1162
1163     if( ( n == 0 ) || ( n > tv->num_cols ) )
1164         return ERROR_INVALID_PARAMETER;
1165
1166     if( name )
1167     {
1168         *name = strdupW( tv->columns[n-1].colname );
1169         if( !*name )
1170             return ERROR_FUNCTION_FAILED;
1171     }
1172     if( type )
1173         *type = tv->columns[n-1].type;
1174
1175     return ERROR_SUCCESS;
1176 }
1177
1178 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row );
1179
1180 static UINT table_validate_new( MSITABLEVIEW *tv, MSIRECORD *rec )
1181 {
1182     UINT r, row, i;
1183
1184     /* check there's no null values where they're not allowed */
1185     for( i = 0; i < tv->num_cols; i++ )
1186     {
1187         if ( tv->columns[i].type & MSITYPE_NULLABLE )
1188             continue;
1189
1190         if ( MSITYPE_IS_BINARY(tv->columns[i].type) )
1191             TRACE("skipping binary column\n");
1192         else if ( tv->columns[i].type & MSITYPE_STRING )
1193         {
1194             LPCWSTR str;
1195
1196             str = MSI_RecordGetString( rec, i+1 );
1197             if (str == NULL || str[0] == 0)
1198                 return ERROR_INVALID_DATA;
1199         }
1200         else
1201         {
1202             UINT n;
1203
1204             n = MSI_RecordGetInteger( rec, i+1 );
1205             if (n == MSI_NULL_INTEGER)
1206                 return ERROR_INVALID_DATA;
1207         }
1208     }
1209
1210     /* check there's no duplicate keys */
1211     r = msi_table_find_row( tv, rec, &row );
1212     if (r == ERROR_SUCCESS)
1213         return ERROR_INVALID_DATA;
1214
1215     return ERROR_SUCCESS;
1216 }
1217
1218 static UINT TABLE_insert_row( struct tagMSIVIEW *view, MSIRECORD *rec )
1219 {
1220     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1221     UINT r, row = -1;
1222
1223     TRACE("%p %p\n", tv, rec );
1224
1225     /* check that the key is unique - can we find a matching row? */
1226     r = table_validate_new( tv, rec );
1227     if( r != ERROR_SUCCESS )
1228         return ERROR_FUNCTION_FAILED;
1229
1230     r = table_create_new_row( view, &row );
1231     TRACE("insert_row returned %08x\n", r);
1232     if( r != ERROR_SUCCESS )
1233         return r;
1234
1235     return TABLE_set_row( view, row, rec, (1<<tv->num_cols) - 1 );
1236 }
1237
1238 static UINT TABLE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
1239                 MSIRECORD *rec)
1240 {
1241     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1242     UINT r;
1243
1244     TRACE("%p %d %p\n", view, eModifyMode, rec );
1245
1246     if (!tv->table)
1247     {
1248         r = TABLE_execute( view, NULL );
1249         if( r )
1250             return r;
1251     }
1252
1253     switch (eModifyMode)
1254     {
1255     case MSIMODIFY_VALIDATE_NEW:
1256         r = table_validate_new( tv, rec );
1257         break;
1258
1259     case MSIMODIFY_INSERT_TEMPORARY:
1260         r = table_validate_new( tv, rec );
1261         if (r != ERROR_SUCCESS)
1262             break;
1263         r = TABLE_insert_row( view, rec );
1264         break;
1265
1266     case MSIMODIFY_REFRESH:
1267     case MSIMODIFY_INSERT:
1268     case MSIMODIFY_UPDATE:
1269     case MSIMODIFY_ASSIGN:
1270     case MSIMODIFY_REPLACE:
1271     case MSIMODIFY_MERGE:
1272     case MSIMODIFY_DELETE:
1273     case MSIMODIFY_VALIDATE:
1274     case MSIMODIFY_VALIDATE_FIELD:
1275     case MSIMODIFY_VALIDATE_DELETE:
1276         FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
1277         r = ERROR_CALL_NOT_IMPLEMENTED;
1278         break;
1279
1280     default:
1281         r = ERROR_INVALID_DATA;
1282     }
1283
1284     return r;
1285 }
1286
1287 static UINT TABLE_delete( struct tagMSIVIEW *view )
1288 {
1289     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1290
1291     TRACE("%p\n", view );
1292
1293     tv->table = NULL;
1294
1295     if( tv->columns )
1296     {
1297         msi_free_colinfo( tv->columns, tv->num_cols );
1298         msi_free( tv->columns );
1299     }
1300     tv->columns = NULL;
1301
1302     msi_free( tv );
1303
1304     return ERROR_SUCCESS;
1305 }
1306
1307 static UINT TABLE_find_matching_rows( struct tagMSIVIEW *view, UINT col,
1308     UINT val, UINT *row, MSIITERHANDLE *handle )
1309 {
1310     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1311     const MSICOLUMNHASHENTRY *entry;
1312
1313     TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
1314
1315     if( !tv->table )
1316         return ERROR_INVALID_PARAMETER;
1317
1318     if( (col==0) || (col > tv->num_cols) )
1319         return ERROR_INVALID_PARAMETER;
1320
1321     if( !tv->columns[col-1].hash_table )
1322     {
1323         UINT i;
1324         UINT num_rows = tv->table->row_count;
1325         MSICOLUMNHASHENTRY **hash_table;
1326         MSICOLUMNHASHENTRY *new_entry;
1327
1328         if( tv->columns[col-1].offset >= tv->row_size )
1329         {
1330             ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1331             ERR("%p %p\n", tv, tv->columns );
1332             return ERROR_FUNCTION_FAILED;
1333         }
1334
1335         /* allocate contiguous memory for the table and its entries so we
1336          * don't have to do an expensive cleanup */
1337         hash_table = msi_alloc(MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*) +
1338             num_rows * sizeof(MSICOLUMNHASHENTRY));
1339         if (!hash_table)
1340             return ERROR_OUTOFMEMORY;
1341
1342         memset(hash_table, 0, MSITABLE_HASH_TABLE_SIZE * sizeof(MSICOLUMNHASHENTRY*));
1343         tv->columns[col-1].hash_table = hash_table;
1344
1345         new_entry = (MSICOLUMNHASHENTRY *)(hash_table + MSITABLE_HASH_TABLE_SIZE);
1346
1347         for (i = 0; i < num_rows; i++, new_entry++)
1348         {
1349             UINT row_value, n;
1350             UINT offset = i + (tv->columns[col-1].offset/2) * num_rows;
1351             n = bytes_per_column( &tv->columns[col-1] );
1352             switch( n )
1353             {
1354             case 4:
1355                 offset = tv->columns[col-1].offset/2;
1356                 row_value = tv->table->data[i][offset] +
1357                     (tv->table->data[i][offset + 1] << 16);
1358                 break;
1359             case 2:
1360                 offset = tv->columns[col-1].offset/2;
1361                 row_value = tv->table->data[i][offset];
1362                 break;
1363             default:
1364                 ERR("oops! what is %d bytes per column?\n", n );
1365                 continue;
1366             }
1367
1368             new_entry->next = NULL;
1369             new_entry->value = row_value;
1370             new_entry->row = i;
1371             if (hash_table[row_value % MSITABLE_HASH_TABLE_SIZE])
1372             {
1373                 MSICOLUMNHASHENTRY *prev_entry = hash_table[row_value % MSITABLE_HASH_TABLE_SIZE];
1374                 while (prev_entry->next)
1375                     prev_entry = prev_entry->next;
1376                 prev_entry->next = new_entry;
1377             }
1378             else
1379                 hash_table[row_value % MSITABLE_HASH_TABLE_SIZE] = new_entry;
1380         }
1381     }
1382
1383     if( !*handle )
1384         entry = tv->columns[col-1].hash_table[val % MSITABLE_HASH_TABLE_SIZE];
1385     else
1386         entry = (*handle)->next;
1387
1388     while (entry && entry->value != val)
1389         entry = entry->next;
1390
1391     *handle = entry;
1392     if (!entry)
1393         return ERROR_NO_MORE_ITEMS;
1394
1395     *row = entry->row;
1396     return ERROR_SUCCESS;
1397 }
1398
1399
1400 static const MSIVIEWOPS table_ops =
1401 {
1402     TABLE_fetch_int,
1403     TABLE_fetch_stream,
1404     TABLE_set_row,
1405     TABLE_insert_row,
1406     TABLE_execute,
1407     TABLE_close,
1408     TABLE_get_dimensions,
1409     TABLE_get_column_info,
1410     TABLE_modify,
1411     TABLE_delete,
1412     TABLE_find_matching_rows
1413 };
1414
1415 UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
1416 {
1417     MSITABLEVIEW *tv ;
1418     UINT r, sz, column_count;
1419     MSICOLUMNINFO *columns;
1420
1421     TRACE("%p %s %p\n", db, debugstr_w(name), view );
1422
1423     /* get the number of columns in this table */
1424     column_count = 0;
1425     r = get_tablecolumns( db, name, NULL, &column_count );
1426     if( r != ERROR_SUCCESS )
1427         return r;
1428
1429     /* if there's no columns, there's no table */
1430     if( column_count == 0 )
1431         return ERROR_INVALID_PARAMETER;
1432
1433     TRACE("Table found\n");
1434
1435     sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ;
1436     tv = msi_alloc_zero( sz );
1437     if( !tv )
1438         return ERROR_FUNCTION_FAILED;
1439
1440     columns = msi_alloc( column_count*sizeof (MSICOLUMNINFO));
1441     if( !columns )
1442     {
1443         msi_free( tv );
1444         return ERROR_FUNCTION_FAILED;
1445     }
1446
1447     r = get_tablecolumns( db, name, columns, &column_count );
1448     if( r != ERROR_SUCCESS )
1449     {
1450         msi_free( columns );
1451         msi_free( tv );
1452         return ERROR_FUNCTION_FAILED;
1453     }
1454
1455     TRACE("Table has %d columns\n", column_count);
1456
1457     /* fill the structure */
1458     tv->view.ops = &table_ops;
1459     tv->db = db;
1460     tv->columns = columns;
1461     tv->num_cols = column_count;
1462     tv->table = NULL;
1463     tv->row_size = msi_table_get_row_size( columns, column_count );
1464
1465     TRACE("%s one row is %d bytes\n", debugstr_w(name), tv->row_size );
1466
1467     *view = (MSIVIEW*) tv;
1468     lstrcpyW( tv->name, name );
1469
1470     return ERROR_SUCCESS;
1471 }
1472
1473 UINT MSI_CommitTables( MSIDATABASE *db )
1474 {
1475     UINT r;
1476     MSITABLE *table = NULL;
1477
1478     TRACE("%p\n",db);
1479
1480     r = msi_save_string_table( db->strings, db->storage );
1481     if( r != ERROR_SUCCESS )
1482     {
1483         WARN("failed to save string table r=%08x\n",r);
1484         return r;
1485     }
1486
1487     LIST_FOR_EACH_ENTRY( table, &db->tables, MSITABLE, entry )
1488     {
1489         r = save_table( db, table );
1490         if( r != ERROR_SUCCESS )
1491         {
1492             WARN("failed to save table %s (r=%08x)\n",
1493                   debugstr_w(table->name), r);
1494             return r;
1495         }
1496     }
1497
1498     /* force everything to reload next time */
1499     free_cached_tables( db );
1500
1501     return ERROR_SUCCESS;
1502 }
1503
1504 MSICONDITION MSI_DatabaseIsTablePersistent( MSIDATABASE *db, LPCWSTR table )
1505 {
1506     if (!table)
1507         return MSICONDITION_ERROR;
1508
1509     if (!TABLE_Exists( db, table ))
1510         return MSICONDITION_NONE;
1511
1512     return MSICONDITION_FALSE;
1513 }
1514
1515 static MSIRECORD *msi_get_transform_record( MSITABLEVIEW *tv, string_table *st, USHORT *rawdata )
1516 {
1517     UINT i, val, ofs = 0;
1518     USHORT mask = *rawdata++;
1519     MSICOLUMNINFO *columns = tv->columns;
1520     MSIRECORD *rec;
1521
1522     rec = MSI_CreateRecord( tv->num_cols );
1523     if( !rec )
1524         return rec;
1525
1526     TRACE("row ->\n");
1527     for( i=0; i<tv->num_cols; i++ )
1528     {
1529         UINT n = bytes_per_column( &columns[i] );
1530
1531         if ( (mask&1) && (i>=(mask>>8)) )
1532             break;
1533         /* all keys must be present */
1534         if ( (~mask&1) && (~columns[i].type & MSITYPE_KEY) && ((1<<i) & ~mask) )
1535             continue;
1536
1537         switch( n )
1538         {
1539         case 2:
1540             val = rawdata[ofs];
1541             if( (columns[i].type & MSITYPE_STRING) &&
1542                 ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1543             {
1544                 LPCWSTR sval = msi_string_lookup_id( st, val );
1545                 MSI_RecordSetStringW( rec, i+1, sval );
1546                 TRACE(" field %d [%s]\n", i+1, debugstr_w(sval));
1547             }
1548             else
1549             {
1550                 if (val)
1551                     MSI_RecordSetInteger( rec, i+1, val^0x8000 );
1552                 TRACE(" field %d [0x%04x]\n", i+1, val );
1553             }
1554             break;
1555         case 4:
1556             val = (rawdata[ofs] + (rawdata[ofs + 1]<<16));
1557             if (val)
1558                 MSI_RecordSetInteger( rec, i+1, val^0x80000000 );
1559             TRACE(" field %d [0x%08x]\n", i+1, val );
1560             break;
1561         default:
1562             ERR("oops - unknown column width %d\n", n);
1563             break;
1564         }
1565         ofs += n/2;
1566     }
1567     return rec;
1568 }
1569
1570 static void dump_record( MSIRECORD *rec )
1571 {
1572     UINT i, n;
1573
1574     n = MSI_RecordGetFieldCount( rec );
1575     for( i=1; i<=n; i++ )
1576     {
1577         LPCWSTR sval = MSI_RecordGetString( rec, i );
1578
1579         if( MSI_RecordIsNull( rec, i ) )
1580             TRACE("row -> []\n");
1581         else if( (sval = MSI_RecordGetString( rec, i )) )
1582             TRACE("row -> [%s]\n", debugstr_w(sval));
1583         else
1584             TRACE("row -> [0x%08x]\n", MSI_RecordGetInteger( rec, i ) );
1585     }
1586 }
1587
1588 static void dump_table( string_table *st, USHORT *rawdata, UINT rawsize )
1589 {
1590     LPCWSTR sval;
1591     UINT i;
1592
1593     for( i=0; i<(rawsize/2); i++ )
1594     {
1595         sval = msi_string_lookup_id( st, rawdata[i] );
1596         MESSAGE(" %04x %s\n", rawdata[i], debugstr_w(sval) );
1597     }
1598 }
1599
1600 static UINT* msi_record_to_row( MSITABLEVIEW *tv, MSIRECORD *rec )
1601 {
1602     LPCWSTR str;
1603     UINT i, r, *data;
1604
1605     data = msi_alloc( tv->num_cols *sizeof (UINT) );
1606     for( i=0; i<tv->num_cols; i++ )
1607     {
1608         data[i] = 0;
1609
1610         if ( ~tv->columns[i].type & MSITYPE_KEY )
1611             continue;
1612
1613         /* turn the transform column value into a row value */
1614         if ( ( tv->columns[i].type & MSITYPE_STRING ) &&
1615              ! MSITYPE_IS_BINARY(tv->columns[i].type) )
1616         {
1617             str = MSI_RecordGetString( rec, i+1 );
1618             r = msi_string2idW( tv->db->strings, str, &data[i] );
1619
1620             /* if there's no matching string in the string table,
1621                these keys can't match any record, so fail now. */
1622             if( ERROR_SUCCESS != r )
1623             {
1624                 msi_free( data );
1625                 return NULL;
1626             }
1627         }
1628         else
1629         {
1630             data[i] = MSI_RecordGetInteger( rec, i+1 );
1631             if ((tv->columns[i].type&0xff) == 2)
1632                 data[i] += 0x8000;
1633             else
1634                 data[i] += 0x80000000;
1635         }
1636     }
1637     return data;
1638 }
1639
1640 static UINT msi_row_matches( MSITABLEVIEW *tv, UINT row, UINT *data )
1641 {
1642     UINT i, r, x, ret = ERROR_FUNCTION_FAILED;
1643
1644     for( i=0; i<tv->num_cols; i++ )
1645     {
1646         if ( ~tv->columns[i].type & MSITYPE_KEY )
1647             continue;
1648
1649         /* turn the transform column value into a row value */
1650         r = TABLE_fetch_int( &tv->view, row, i+1, &x );
1651         if ( r != ERROR_SUCCESS )
1652         {
1653             ERR("TABLE_fetch_int shouldn't fail here\n");
1654             break;
1655         }
1656
1657         /* if this key matches, move to the next column */
1658         if ( x != data[i] )
1659         {
1660             ret = ERROR_FUNCTION_FAILED;
1661             break;
1662         }
1663
1664         ret = ERROR_SUCCESS;
1665     }
1666
1667     return ret;
1668 }
1669
1670 static UINT msi_table_find_row( MSITABLEVIEW *tv, MSIRECORD *rec, UINT *row )
1671 {
1672     UINT i, r = ERROR_FUNCTION_FAILED, *data;
1673
1674     data = msi_record_to_row( tv, rec );
1675     if( !data )
1676         return r;
1677     for( i=0; i<tv->table->row_count; i++ )
1678     {
1679         r = msi_row_matches( tv, i, data );
1680         if( r == ERROR_SUCCESS )
1681         {
1682             *row = i;
1683             break;
1684         }
1685     }
1686     msi_free( data );
1687     return r;
1688 }
1689
1690 static UINT msi_delete_row( MSITABLEVIEW *tv, UINT row )
1691 {
1692     UINT i;
1693
1694     for( i=1; i<=tv->num_cols; i++ )
1695         TABLE_set_int( tv, row, i, 0 );
1696     return ERROR_SUCCESS;
1697 }
1698
1699 static UINT msi_table_load_transform( MSIDATABASE *db, IStorage *stg,
1700                                       string_table *st, LPCWSTR name )
1701 {
1702     UINT rawsize = 0;
1703     USHORT *rawdata = NULL;
1704     MSITABLEVIEW *tv = NULL;
1705     UINT r, n, sz, i, mask;
1706     MSIRECORD *rec = NULL;
1707     UINT colcol = 0;
1708     WCHAR coltable[32];
1709
1710     coltable[0] = 0;
1711     TRACE("%p %p %p %s\n", db, stg, st, debugstr_w(name) );
1712
1713     /* read the transform data */
1714     read_stream_data( stg, name, &rawdata, &rawsize );
1715     if ( !rawdata )
1716     {
1717         TRACE("table %s empty\n", debugstr_w(name) );
1718         return ERROR_INVALID_TABLE;
1719     }
1720
1721     /* create a table view */
1722     r = TABLE_CreateView( db, name, (MSIVIEW**) &tv );
1723     if( r != ERROR_SUCCESS )
1724         goto err;
1725
1726     r = tv->view.ops->execute( &tv->view, NULL );
1727     if( r != ERROR_SUCCESS )
1728         goto err;
1729
1730     TRACE("name = %s columns = %u row_size = %u raw size = %u\n",
1731           debugstr_w(name), tv->num_cols, tv->row_size, rawsize );
1732
1733     /* interpret the data */
1734     r = ERROR_SUCCESS;
1735     for( n=0; n < (rawsize/2);  )
1736     {
1737         mask = rawdata[n];
1738
1739         if (mask&1)
1740         {
1741             /*
1742              * if the low bit is set, columns are continuous and
1743              * the number of columns is specified in the high byte
1744              */
1745             sz = 2 + tv->row_size;
1746         }
1747         else
1748         {
1749             /*
1750              * If the low bit is not set, rowdata[n] is a bitmask.
1751              * Excepting for key fields, which are always present,
1752              *  each bit indicates that a field is present in the transform record.
1753              *
1754              * rawdata[n] == 0 is a special case ... only the keys will be present
1755              * and it means that this row should be deleted.
1756              */
1757             sz = 2;
1758             for( i=0; i<tv->num_cols; i++ )
1759             {
1760                 if( (tv->columns[i].type & MSITYPE_KEY) || ((1<<i)&mask))
1761                     sz += bytes_per_column( &tv->columns[i] );
1762             }
1763         }
1764
1765         /* check we didn't run of the end of the table */
1766         if ( (n+sz) > rawsize )
1767         {
1768             ERR("borked.\n");
1769             dump_table( st, rawdata, rawsize );
1770             break;
1771         }
1772
1773         rec = msi_get_transform_record( tv, st, &rawdata[n] );
1774         if (rec)
1775         {
1776             if ( mask & 1 )
1777             {
1778                 TRACE("inserting record\n");
1779
1780                 /*
1781                  * Native msi seems writes nul into the
1782                  * Number (2nd) column of the _Columns table.
1783                  * Not sure that it's deliberate...
1784                  */
1785                 if (!lstrcmpW(name, szColumns))
1786                 {
1787                     WCHAR table[32];
1788                     DWORD sz = 32;
1789
1790                     MSI_RecordGetStringW( rec, 1, table, &sz );
1791
1792                     /* reset the column number on a new table */
1793                     if ( lstrcmpW(coltable, table) )
1794                     {
1795                         colcol = 0;
1796                         lstrcpyW( coltable, table );
1797                     }
1798
1799                     /* fix nul column numbers */
1800                     MSI_RecordSetInteger( rec, 2, ++colcol );
1801                 }
1802
1803                 r = TABLE_insert_row( &tv->view, rec );
1804                 if (r != ERROR_SUCCESS)
1805                     ERR("insert row failed\n");
1806             }
1807             else
1808             {
1809                 UINT row = 0;
1810
1811                 r = msi_table_find_row( tv, rec, &row );
1812                 if (r != ERROR_SUCCESS)
1813                     ERR("no matching row to transform\n");
1814                 else if ( mask )
1815                 {
1816                     TRACE("modifying row [%d]:\n", row);
1817                     TABLE_set_row( &tv->view, row, rec, mask );
1818                 }
1819                 else
1820                 {
1821                     TRACE("deleting row [%d]:\n", row);
1822                     msi_delete_row( tv, row );
1823                 }
1824             }
1825             if( TRACE_ON(msidb) ) dump_record( rec );
1826             msiobj_release( &rec->hdr );
1827         }
1828
1829         n += sz/2;
1830     }
1831
1832 err:
1833     /* no need to free the table, it's associated with the database */
1834     msi_free( rawdata );
1835     if( tv )
1836         tv->view.ops->delete( &tv->view );
1837
1838     return ERROR_SUCCESS;
1839 }
1840
1841 /*
1842  * msi_table_apply_transform
1843  *
1844  * Enumerate the table transforms in a transform storage and apply each one.
1845  */
1846 UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
1847 {
1848     IEnumSTATSTG *stgenum = NULL;
1849     HRESULT r;
1850     STATSTG stat;
1851     ULONG count;
1852     WCHAR name[0x40];
1853     string_table *strings;
1854     UINT ret = ERROR_FUNCTION_FAILED;
1855
1856     TRACE("%p %p\n", db, stg );
1857
1858     strings = msi_load_string_table( stg );
1859     if( !strings )
1860         goto end;
1861
1862     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
1863     if( FAILED( r ) )
1864         goto end;
1865
1866     /*
1867      * Apply _Tables and _Columns transforms first so that
1868      * the table metadata is correct, and empty tables exist.
1869      */
1870     ret = msi_table_load_transform( db, stg, strings, szTables );
1871     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
1872         goto end;
1873
1874     ret = msi_table_load_transform( db, stg, strings, szColumns );
1875     if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
1876         goto end;
1877
1878     ret = ERROR_SUCCESS;
1879
1880     while( r == ERROR_SUCCESS )
1881     {
1882         count = 0;
1883         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
1884         if( FAILED( r ) || !count )
1885             break;
1886
1887         decode_streamname( stat.pwcsName, name );
1888         if ( name[0] != 0x4840 )
1889             continue;
1890
1891         TRACE("transform contains stream %s\n", debugstr_w(name));
1892
1893         if ( !lstrcmpW( name+1, szStringPool ) ||
1894              !lstrcmpW( name+1, szStringData ) ||
1895              !lstrcmpW( name+1, szColumns ) ||
1896              !lstrcmpW( name+1, szTables ) )
1897             continue;
1898
1899         ret = msi_table_load_transform( db, stg, strings, name+1 );
1900     }
1901
1902     if ( ret == ERROR_SUCCESS )
1903         append_storage_to_db( db, stg );
1904
1905 end:
1906     if ( stgenum )
1907         IEnumSTATSTG_Release( stgenum );
1908     if ( strings )
1909         msi_destroy_stringtable( strings );
1910
1911     return ret;
1912 }
1913
1914 void append_storage_to_db( MSIDATABASE *db, IStorage *stg )
1915 {
1916     MSITRANSFORM *t;
1917
1918     t = msi_alloc( sizeof *t );
1919     t->stg = stg;
1920     IStorage_AddRef( stg );
1921     list_add_tail( &db->transforms, &t->entry );
1922 }
1923
1924 void msi_free_transforms( MSIDATABASE *db )
1925 {
1926     while( !list_empty( &db->transforms ) )
1927     {
1928         MSITRANSFORM *t = LIST_ENTRY( list_head( &db->transforms ),
1929                                       MSITRANSFORM, entry );
1930         list_remove( &t->entry );
1931         IStorage_Release( t->stg );
1932         msi_free( t );
1933     }
1934 }