dlls/msi/table.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2002-2004 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #include "wine/debug.h"
  31 #include "msi.h"
  32 #include "msiquery.h"
  33 #include "objbase.h"
  34 #include "objidl.h"
  35 #include "msipriv.h"
  36 #include "winnls.h"
  37
  38 #include "query.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  41
  42 typedef struct tagMSICOLUMNINFO
  43 {
  44     LPWSTR tablename;
  45     UINT   number;
  46     LPWSTR colname;
  47     UINT   type;
  48     UINT   offset;
  49 } MSICOLUMNINFO;
  50
  51 struct tagMSITABLE
  52 {
  53     USHORT **data;
  54     UINT ref_count;
  55     UINT row_count;
  56     struct tagMSITABLE *next;
  57     struct tagMSITABLE *prev;
  58     WCHAR name[1];
  59 };
  60
  61 #define MAX_STREAM_NAME 0x1f
  62
  63 static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name,
  64        MSICOLUMNINFO **pcols, UINT *pcount );
  65 static UINT get_tablecolumns( MSIDATABASE *db,
  66        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz);
  67
  68 static inline UINT bytes_per_column( MSICOLUMNINFO *col )
  69 {
  70     if( col->type & MSITYPE_STRING )
  71         return 2;
  72     if( (col->type & 0xff) > 4 )
  73         ERR("Invalid column size!\n");
  74     return col->type & 0xff;
  75 }
  76
  77 static int utf2mime(int x)
  78 {
  79     if( (x>='0') && (x<='9') )
  80         return x-'0';
  81     if( (x>='A') && (x<='Z') )
  82         return x-'A'+10;
  83     if( (x>='a') && (x<='z') )
  84         return x-'a'+10+26;
  85     if( x=='.' )
  86         return 10+26+26;
  87     if( x=='_' )
  88         return 10+26+26+1;
  89     return -1;
  90 }
  91
  92 static LPWSTR encode_streamname(BOOL bTable, LPCWSTR in)
  93 {
  94     DWORD count = MAX_STREAM_NAME;
  95     DWORD ch, next;
  96     LPWSTR out, p;
  97
  98     if( !bTable )
  99         count = lstrlenW( in )+2;
 100     out = HeapAlloc( GetProcessHeap(), 0, count*sizeof(WCHAR) );
 101     p = out;
 102
 103     if( bTable )
 104     {
 105          *p++ = 0x4840;
 106          count --;
 107     }
 108     while( count -- )
 109     {
 110         ch = *in++;
 111         if( !ch )
 112         {
 113             *p = ch;
 114             return out;
 115         }
 116         if( ( ch < 0x80 ) && ( utf2mime(ch) >= 0 ) )
 117         {
 118             ch = utf2mime(ch) + 0x4800;
 119             next = *in;
 120             if( next && (next<0x80) )
 121             {
 122                 next = utf2mime(next);
 123                 if( next >= 0  )
 124                 {
 125                      next += 0x3ffffc0;
 126                      ch += (next<<6);
 127                      in++;
 128                 }
 129             }
 130         }
 131         *p++ = ch;
 132     }
 133     ERR("Failed to encode stream name (%s)\n",debugstr_w(in));
 134     HeapFree( GetProcessHeap(), 0, out );
 135     return NULL;
 136 }
 137
 138 static int mime2utf(int x)
 139 {
 140     if( x<10 )
 141         return x + '0';
 142     if( x<(10+26))
 143         return x - 10 + 'A';
 144     if( x<(10+26+26))
 145         return x - 10 - 26 + 'a';
 146     if( x == (10+26+26) )
 147         return '.';
 148     return '_';
 149 }
 150
 151 static BOOL decode_streamname(LPWSTR in, LPWSTR out)
 152 {
 153     WCHAR ch;
 154     DWORD count = 0;
 155
 156     while ( (ch = *in++) )
 157     {
 158         if( (ch >= 0x3800 ) && (ch < 0x4840 ) )
 159         {
 160             if( ch >= 0x4800 )
 161                 ch = mime2utf(ch-0x4800);
 162             else
 163             {
 164                 ch -= 0x3800;
 165                 *out++ = mime2utf(ch&0x3f);
 166                 count++;
 167                 ch = mime2utf((ch>>6)&0x3f);
 168             }
 169         }
 170         *out++ = ch;
 171         count++;
 172     }
 173     *out = 0;
 174     return count;
 175 }
 176
 177 void enum_stream_names( IStorage *stg )
 178 {
 179     IEnumSTATSTG *stgenum = NULL;
 180     HRESULT r;
 181     STATSTG stat;
 182     ULONG n, count;
 183     WCHAR name[0x40];
 184
 185     r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
 186     if( FAILED( r ) )
 187         return;
 188
 189     n = 0;
 190     while( 1 )
 191     {
 192         count = 0;
 193         r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
 194         if( FAILED( r ) || !count )
 195             break;
 196         decode_streamname( stat.pwcsName, name );
 197         TRACE("stream %2ld -> %s %s\n", n,
 198               debugstr_w(stat.pwcsName), debugstr_w(name) );
 199         n++;
 200     }
 201
 202     IEnumSTATSTG_Release( stgenum );
 203 }
 204
 205 static UINT read_stream_data( IStorage *stg, LPCWSTR stname,
 206                               USHORT **pdata, UINT *psz )
 207 {
 208     HRESULT r;
 209     UINT ret = ERROR_FUNCTION_FAILED;
 210     VOID *data;
 211     ULONG sz, count;
 212     IStream *stm = NULL;
 213     STATSTG stat;
 214     LPWSTR encname;
 215
 216     encname = encode_streamname(TRUE, stname);
 217
 218     TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
 219
 220     r = IStorage_OpenStream(stg, encname, NULL,
 221             STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
 222     HeapFree( GetProcessHeap(), 0, encname );
 223     if( FAILED( r ) )
 224     {
 225         WARN("open stream failed r = %08lx - empty table?\n",r);
 226         return ret;
 227     }
 228
 229     r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
 230     if( FAILED( r ) )
 231     {
 232         WARN("open stream failed r = %08lx!\n",r);
 233         goto end;
 234     }
 235
 236     if( stat.cbSize.QuadPart >> 32 )
 237     {
 238         WARN("Too big!\n");
 239         goto end;
 240     }
 241
 242     sz = stat.cbSize.QuadPart;
 243     data = HeapAlloc( GetProcessHeap(), 0, sz );
 244     if( !data )
 245     {
 246         WARN("couldn't allocate memory r=%08lx!\n",r);
 247         ret = ERROR_NOT_ENOUGH_MEMORY;
 248         goto end;
 249     }
 250
 251     r = IStream_Read(stm, data, sz, &count );
 252     if( FAILED( r ) || ( count != sz ) )
 253     {
 254         HeapFree( GetProcessHeap(), 0, data );
 255         WARN("read stream failed r = %08lx!\n",r);
 256         goto end;
 257     }
 258
 259     *pdata = data;
 260     *psz = sz;
 261     ret = ERROR_SUCCESS;
 262
 263 end:
 264     IStream_Release( stm );
 265
 266     return ret;
 267 }
 268
 269 UINT db_get_raw_stream( MSIDATABASE *db, LPCWSTR stname, IStream **stm )
 270 {
 271     LPWSTR encname;
 272     HRESULT r;
 273
 274     encname = encode_streamname(FALSE, stname);
 275
 276     TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
 277
 278     r = IStorage_OpenStream(db->storage, encname, NULL,
 279             STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm);
 280     HeapFree( GetProcessHeap(), 0, encname );
 281     if( FAILED( r ) )
 282     {
 283         WARN("open stream failed r = %08lx - empty table?\n",r);
 284         return ERROR_FUNCTION_FAILED;
 285     }
 286
 287     return ERROR_SUCCESS;
 288 }
 289
 290 UINT read_raw_stream_data( MSIDATABASE *db, LPCWSTR stname,
 291                               USHORT **pdata, UINT *psz )
 292 {
 293     HRESULT r;
 294     UINT ret = ERROR_FUNCTION_FAILED;
 295     VOID *data;
 296     ULONG sz, count;
 297     IStream *stm = NULL;
 298     STATSTG stat;
 299
 300     r = db_get_raw_stream( db, stname, &stm );
 301     if( r != ERROR_SUCCESS)
 302         return ret;
 303     r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
 304     if( FAILED( r ) )
 305     {
 306         WARN("open stream failed r = %08lx!\n",r);
 307         goto end;
 308     }
 309
 310     if( stat.cbSize.QuadPart >> 32 )
 311     {
 312         WARN("Too big!\n");
 313         goto end;
 314     }
 315
 316     sz = stat.cbSize.QuadPart;
 317     data = HeapAlloc( GetProcessHeap(), 0, sz );
 318     if( !data )
 319     {
 320         WARN("couldn't allocate memory r=%08lx!\n",r);
 321         ret = ERROR_NOT_ENOUGH_MEMORY;
 322         goto end;
 323     }
 324
 325     r = IStream_Read(stm, data, sz, &count );
 326     if( FAILED( r ) || ( count != sz ) )
 327     {
 328         HeapFree( GetProcessHeap(), 0, data );
 329         WARN("read stream failed r = %08lx!\n",r);
 330         goto end;
 331     }
 332
 333     *pdata = data;
 334     *psz = sz;
 335     ret = ERROR_SUCCESS;
 336
 337 end:
 338     IStream_Release( stm );
 339
 340     return ret;
 341 }
 342
 343 static UINT write_stream_data( IStorage *stg, LPCWSTR stname,
 344                                LPVOID data, UINT sz )
 345 {
 346     HRESULT r;
 347     UINT ret = ERROR_FUNCTION_FAILED;
 348     ULONG count;
 349     IStream *stm = NULL;
 350     ULARGE_INTEGER size;
 351     LARGE_INTEGER pos;
 352     LPWSTR encname;
 353
 354     encname = encode_streamname(TRUE, stname );
 355     r = IStorage_OpenStream( stg, encname, NULL,
 356             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
 357     if( FAILED(r) )
 358     {
 359         r = IStorage_CreateStream( stg, encname,
 360                 STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
 361     }
 362     HeapFree( GetProcessHeap(), 0, encname );
 363     if( FAILED( r ) )
 364     {
 365         WARN("open stream failed r = %08lx\n",r);
 366         return ret;
 367     }
 368
 369     size.QuadPart = sz;
 370     r = IStream_SetSize( stm, size );
 371     if( FAILED( r ) )
 372     {
 373         WARN("Failed to SetSize\n");
 374         goto end;
 375     }
 376
 377     pos.QuadPart = 0;
 378     r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
 379     if( FAILED( r ) )
 380     {
 381         WARN("Failed to Seek\n");
 382         goto end;
 383     }
 384
 385     r = IStream_Write(stm, data, sz, &count );
 386     if( FAILED( r ) || ( count != sz ) )
 387     {
 388         WARN("Failed to Write\n");
 389         goto end;
 390     }
 391
 392     ret = ERROR_SUCCESS;
 393
 394 end:
 395     IStream_Release( stm );
 396
 397     return ret;
 398 }
 399
 400 static UINT read_table_from_storage( MSIDATABASE *db, LPCWSTR name, MSITABLE **ptable)
 401 {
 402     MSITABLE *t;
 403     USHORT *rawdata = NULL;
 404     UINT rawsize = 0, r, i, j, row_size = 0, num_cols = 0;
 405     MSICOLUMNINFO *cols, *last_col;
 406
 407     TRACE("%s\n",debugstr_w(name));
 408
 409     /* nonexistent tables should be interpreted as empty tables */
 410     t = HeapAlloc( GetProcessHeap(), 0,
 411                    sizeof (MSITABLE) + lstrlenW(name)*sizeof (WCHAR) );
 412     if( !t )
 413         return ERROR_NOT_ENOUGH_MEMORY;
 414
 415     r = table_get_column_info( db, name, &cols, &num_cols );
 416     if( r != ERROR_SUCCESS )
 417     {
 418         HeapFree( GetProcessHeap(), 0, t );
 419         return r;
 420     }
 421     last_col = &cols[num_cols-1];
 422     row_size = last_col->offset + bytes_per_column( last_col );
 423
 424     t->row_count = 0;
 425     t->data = NULL;
 426     lstrcpyW( t->name, name );
 427     t->ref_count = 1;
 428     *ptable = t;
 429
 430     /* if we can't read the table, just assume that it's empty */
 431     read_stream_data( db->storage, name, &rawdata, &rawsize );
 432     if( !rawdata )
 433         return ERROR_SUCCESS;
 434
 435     TRACE("Read %d bytes\n", rawsize );
 436
 437     if( rawsize % row_size )
 438     {
 439         WARN("Table size is invalid %d/%d\n", rawsize, row_size );
 440         return ERROR_FUNCTION_FAILED;
 441     }
 442
 443     t->row_count = rawsize / row_size;
 444     t->data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 445                          t->row_count * sizeof (USHORT*) );
 446     if( !t->data )
 447         return ERROR_NOT_ENOUGH_MEMORY;  /* FIXME: memory leak */
 448
 449     /* transpose all the data */
 450     TRACE("Transposing data from %d columns\n", t->row_count );
 451     for( i=0; i<t->row_count; i++ )
 452     {
 453         t->data[i] = HeapAlloc( GetProcessHeap(), 0, row_size );
 454         if( !t->data[i] )
 455             return ERROR_NOT_ENOUGH_MEMORY;  /* FIXME: memory leak */
 456         for( j=0; j<num_cols; j++ )
 457         {
 458             UINT ofs = cols[j].offset/2;
 459             UINT n = bytes_per_column( &cols[j] );
 460
 461             switch( n )
 462             {
 463             case 2:
 464                 t->data[i][ofs] = rawdata[ofs*t->row_count + i ];
 465                 break;
 466             case 4:
 467                 t->data[i][ofs] = rawdata[ofs*t->row_count + i*2 ];
 468                 t->data[i][ofs+1] = rawdata[ofs*t->row_count + i*2 + 1];
 469                 break;
 470             default:
 471                 ERR("oops - unknown column width %d\n", n);
 472                 return ERROR_FUNCTION_FAILED;
 473             }
 474         }
 475     }
 476
 477     HeapFree( GetProcessHeap(), 0, cols );
 478     HeapFree( GetProcessHeap(), 0, rawdata );
 479
 480     return ERROR_SUCCESS;
 481 }
 482
 483 /* add this table to the list of cached tables in the database */
 484 void add_table(MSIDATABASE *db, MSITABLE *table)
 485 {
 486     table->next = db->first_table;
 487     table->prev = NULL;
 488     if( db->first_table )
 489         db->first_table->prev = table;
 490     else
 491         db->last_table = table;
 492     db->first_table = table;
 493 }
 494
 495 /* remove from the list of cached tables */
 496 void remove_table( MSIDATABASE *db, MSITABLE *table )
 497 {
 498     if( table->next )
 499         table->next->prev = table->prev;
 500     else
 501         db->last_table = table->prev;
 502     if( table->prev )
 503         table->prev->next = table->next;
 504     else
 505         db->first_table = table->next;
 506     table->next = NULL;
 507     table->prev = NULL;
 508 }
 509
 510 static void release_table( MSIDATABASE *db, MSITABLE *table )
 511 {
 512     if( !table->ref_count )
 513         ERR("Trying to destroy table with refcount 0\n");
 514     table->ref_count --;
 515     if( !table->ref_count )
 516     {
 517         remove_table( db, table );
 518         HeapFree( GetProcessHeap(), 0, table->data );
 519         HeapFree( GetProcessHeap(), 0, table );
 520         TRACE("Destroyed table %s\n", debugstr_w(table->name));
 521     }
 522 }
 523
 524 void free_cached_tables( MSIDATABASE *db )
 525 {
 526     while( db->first_table )
 527     {
 528         MSITABLE *t = db->first_table;
 529
 530         if ( --t->ref_count )
 531             ERR("table ref count not zero for %s\n", debugstr_w(t->name));
 532         remove_table( db, t );
 533         HeapFree( GetProcessHeap(), 0, t->data );
 534         HeapFree( GetProcessHeap(), 0, t );
 535     }
 536 }
 537
 538 UINT find_cached_table(MSIDATABASE *db, LPCWSTR name, MSITABLE **ptable)
 539 {
 540     MSITABLE *t;
 541
 542     for( t = db->first_table; t; t=t->next )
 543     {
 544         if( !lstrcmpW( name, t->name ) )
 545         {
 546             *ptable = t;
 547             return ERROR_SUCCESS;
 548         }
 549     }
 550
 551     return ERROR_FUNCTION_FAILED;
 552 }
 553
 554 static UINT table_get_column_info( MSIDATABASE *db, LPCWSTR name, MSICOLUMNINFO **pcols, UINT *pcount )
 555 {
 556     UINT r, column_count;
 557     MSICOLUMNINFO *columns;
 558
 559     /* get the number of columns in this table */
 560     column_count = 0;
 561     r = get_tablecolumns( db, name, NULL, &column_count );
 562     if( r != ERROR_SUCCESS )
 563         return r;
 564
 565     /* if there's no columns, there's no table */
 566     if( column_count == 0 )
 567         return ERROR_INVALID_PARAMETER;
 568
 569     TRACE("Table %s found\n", debugstr_w(name) );
 570
 571     columns = HeapAlloc( GetProcessHeap(), 0, column_count*sizeof (MSICOLUMNINFO));
 572     if( !columns )
 573         return ERROR_FUNCTION_FAILED;
 574
 575     r = get_tablecolumns( db, name, columns, &column_count );
 576     if( r != ERROR_SUCCESS )
 577     {
 578         HeapFree( GetProcessHeap(), 0, columns );
 579         return ERROR_FUNCTION_FAILED;
 580     }
 581
 582     *pcols = columns;
 583     *pcount = column_count;
 584
 585     return r;
 586 }
 587
 588 UINT get_table(MSIDATABASE *db, LPCWSTR name, MSITABLE **ptable)
 589 {
 590     UINT r;
 591
 592     *ptable = NULL;
 593
 594     /* first, see if the table is cached */
 595     r = find_cached_table( db, name, ptable );
 596     if( r == ERROR_SUCCESS )
 597     {
 598         (*ptable)->ref_count++;
 599         return r;
 600     }
 601
 602     r = read_table_from_storage( db, name, ptable );
 603     if( r != ERROR_SUCCESS )
 604         return r;
 605
 606     /* add the table to the list */
 607     add_table( db, *ptable );
 608     (*ptable)->ref_count++;
 609
 610     return ERROR_SUCCESS;
 611 }
 612
 613 static UINT save_table( MSIDATABASE *db, MSITABLE *t )
 614 {
 615     USHORT *rawdata = NULL, *p;
 616     UINT rawsize, r, i, j, row_size, num_cols = 0;
 617     MSICOLUMNINFO *cols, *last_col;
 618
 619     TRACE("Saving %s\n", debugstr_w( t->name ) );
 620
 621     r = table_get_column_info( db, t->name, &cols, &num_cols );
 622     if( r != ERROR_SUCCESS )
 623         return r;
 624
 625     last_col = &cols[num_cols-1];
 626     row_size = last_col->offset + bytes_per_column( last_col );
 627
 628     rawsize = t->row_count * row_size;
 629     rawdata = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, rawsize );
 630     if( !rawdata )
 631         return ERROR_NOT_ENOUGH_MEMORY;
 632
 633     p = rawdata;
 634     for( i=0; i<num_cols; i++ )
 635     {
 636         for( j=0; j<t->row_count; j++ )
 637         {
 638             UINT offset = cols[i].offset;
 639
 640             *p++ = t->data[j][offset/2];
 641             if( 4 == bytes_per_column( &cols[i] ) )
 642                 *p++ = t->data[j][offset/2+1];
 643         }
 644     }
 645
 646     TRACE("writing %d bytes\n", rawsize);
 647     r = write_stream_data( db->storage, t->name, rawdata, rawsize );
 648
 649     HeapFree( GetProcessHeap(), 0, rawdata );
 650
 651     return r;
 652 }
 653
 654 HRESULT init_string_table( IStorage *stg )
 655 {
 656     HRESULT r;
 657     static const WCHAR szStringData[] = {
 658         '_','S','t','r','i','n','g','D','a','t','a',0 };
 659     static const WCHAR szStringPool[] = {
 660         '_','S','t','r','i','n','g','P','o','o','l',0 };
 661     USHORT zero[2] = { 0, 0 };
 662     ULONG count = 0;
 663     IStream *stm = NULL;
 664     LPWSTR encname;
 665
 666     encname = encode_streamname(TRUE, szStringPool );
 667
 668     /* create the StringPool stream... add the zero string to it*/
 669     r = IStorage_CreateStream( stg, encname,
 670             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
 671     HeapFree( GetProcessHeap(), 0, encname );
 672     if( r )
 673     {
 674         TRACE("Failed\n");
 675         return r;
 676     }
 677
 678     r = IStream_Write(stm, zero, sizeof zero, &count );
 679     IStream_Release( stm );
 680
 681     if( FAILED( r ) || ( count != sizeof zero ) )
 682     {
 683         TRACE("Failed\n");
 684         return E_FAIL;
 685     }
 686
 687     /* create the StringData stream... make it zero length */
 688     encname = encode_streamname(TRUE, szStringData );
 689     r = IStorage_CreateStream( stg, encname,
 690             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
 691     HeapFree( GetProcessHeap(), 0, encname );
 692     if( r )
 693     {
 694         TRACE("Failed\n");
 695         return E_FAIL;
 696     }
 697     IStream_Release( stm );
 698
 699     return r;
 700 }
 701
 702 UINT load_string_table( MSIDATABASE *db )
 703 {
 704     CHAR *data;
 705     USHORT *pool;
 706     UINT r, ret = ERROR_FUNCTION_FAILED, datasize = 0, poolsize = 0, codepage;
 707     DWORD i, count, offset, len, n;
 708     static const WCHAR szStringData[] = {
 709         '_','S','t','r','i','n','g','D','a','t','a',0 };
 710     static const WCHAR szStringPool[] = {
 711         '_','S','t','r','i','n','g','P','o','o','l',0 };
 712
 713     if( db->strings )
 714     {
 715         msi_destroy_stringtable( db->strings );
 716         db->strings = NULL;
 717     }
 718
 719     r = read_stream_data( db->storage, szStringPool, &pool, &poolsize );
 720     if( r != ERROR_SUCCESS)
 721         goto end;
 722     r = read_stream_data( db->storage, szStringData, (USHORT**)&data, &datasize );
 723     if( r != ERROR_SUCCESS)
 724         goto end;
 725
 726     count = poolsize/4;
 727     if( poolsize > 4 )
 728         codepage = pool[0] | ( pool[1] << 16 );
 729     else
 730         codepage = CP_ACP;
 731     db->strings = msi_init_stringtable( count, codepage );
 732
 733     offset = 0;
 734     for( i=1; i<count; i++ )
 735     {
 736         len = pool[i*2];
 737         n = msi_addstring( db->strings, i, data+offset, len, pool[i*2+1] );
 738         if( n != i )
 739             ERR("Failed to add string %ld\n", i );
 740         offset += len;
 741     }
 742
 743     TRACE("Loaded %ld strings\n", count);
 744
 745     ret = ERROR_SUCCESS;
 746
 747 end:
 748     HeapFree( GetProcessHeap(), 0, pool );
 749     HeapFree( GetProcessHeap(), 0, data );
 750
 751     return ret;
 752 }
 753
 754 static UINT save_string_table( MSIDATABASE *db )
 755 {
 756     UINT i, count, datasize, poolsize, sz, used, r, codepage;
 757     UINT ret = ERROR_FUNCTION_FAILED;
 758     static const WCHAR szStringData[] = {
 759         '_','S','t','r','i','n','g','D','a','t','a',0 };
 760     static const WCHAR szStringPool[] = {
 761         '_','S','t','r','i','n','g','P','o','o','l',0 };
 762     CHAR *data = NULL;
 763     USHORT *pool = NULL;
 764
 765     TRACE("\n");
 766
 767     /* construct the new table in memory first */
 768     datasize = msi_string_totalsize( db->strings, &count );
 769     poolsize = count*2*sizeof(USHORT);
 770
 771     pool = HeapAlloc( GetProcessHeap(), 0, poolsize );
 772     if( ! pool )
 773     {
 774         WARN("Failed to alloc pool %d bytes\n", poolsize );
 775         goto err;
 776     }
 777     data = HeapAlloc( GetProcessHeap(), 0, datasize );
 778     if( ! data )
 779     {
 780         WARN("Failed to alloc data %d bytes\n", poolsize );
 781         goto err;
 782     }
 783
 784     used = 0;
 785     codepage = msi_string_get_codepage( db->strings );
 786     pool[0]=codepage&0xffff;
 787     pool[1]=(codepage>>16);
 788     for( i=1; i<count; i++ )
 789     {
 790         sz = datasize - used;
 791         r = msi_id2stringA( db->strings, i, data+used, &sz );
 792         if( r != ERROR_SUCCESS )
 793         {
 794             ERR("failed to fetch string\n");
 795             sz = 0;
 796         }
 797         if( sz && (sz < (datasize - used ) ) )
 798             sz--;
 799         TRACE("adding %u bytes %s\n", sz, data+used );
 800         pool[ i*2 ] = sz;
 801         pool[ i*2 + 1 ] = msi_id_refcount( db->strings, i );
 802         used += sz;
 803         if( used > datasize  )
 804         {
 805             ERR("oops overran %d >= %d\n", used, datasize);
 806             goto err;
 807         }
 808     }
 809
 810     if( used != datasize )
 811     {
 812         ERR("oops used %d != datasize %d\n", used, datasize);
 813         goto err;
 814     }
 815
 816     /* write the streams */
 817     r = write_stream_data( db->storage, szStringData, data, datasize );
 818     TRACE("Wrote StringData r=%08x\n", r);
 819     if( r )
 820         goto err;
 821     r = write_stream_data( db->storage, szStringPool, pool, poolsize );
 822     TRACE("Wrote StringPool r=%08x\n", r);
 823     if( r )
 824         goto err;
 825
 826     ret = ERROR_SUCCESS;
 827
 828 err:
 829     HeapFree( GetProcessHeap(), 0, data );
 830     HeapFree( GetProcessHeap(), 0, pool );
 831
 832     return ret;
 833 }
 834
 835 /* information for default tables */
 836 static const WCHAR szTables[]  = { '_','T','a','b','l','e','s',0 };
 837 static const WCHAR szTable[]  = { 'T','a','b','l','e',0 };
 838 static const WCHAR szName[]    = { 'N','a','m','e',0 };
 839 static const WCHAR szColumns[] = { '_','C','o','l','u','m','n','s',0 };
 840 static const WCHAR szColumn[]  = { 'C','o','l','u','m','n',0 };
 841 static const WCHAR szNumber[]  = { 'N','u','m','b','e','r',0 };
 842 static const WCHAR szType[]    = { 'T','y','p','e',0 };
 843
 844 struct standard_table {
 845     LPCWSTR tablename;
 846     LPCWSTR columnname;
 847     UINT number;
 848     UINT type;
 849 } MSI_standard_tables[] =
 850 {
 851   { szTables,  szName,   1, MSITYPE_VALID | MSITYPE_STRING | 32},
 852   { szColumns, szTable,  1, MSITYPE_VALID | MSITYPE_STRING | 32},
 853   { szColumns, szNumber, 2, MSITYPE_VALID | 2},
 854   { szColumns, szName,   3, MSITYPE_VALID | MSITYPE_STRING | 32},
 855   { szColumns, szType,   4, MSITYPE_VALID | 2},
 856 };
 857
 858 #define STANDARD_TABLE_COUNT \
 859      (sizeof(MSI_standard_tables)/sizeof(struct standard_table))
 860
 861 static UINT get_defaulttablecolumns( LPCWSTR szTable, MSICOLUMNINFO *colinfo, UINT *sz)
 862 {
 863     DWORD i, n=0;
 864
 865     for(i=0; i<STANDARD_TABLE_COUNT; i++)
 866     {
 867         if( lstrcmpW( szTable, MSI_standard_tables[i].tablename ) )
 868             continue;
 869         if(colinfo && (n < *sz) )
 870         {
 871             colinfo[n].tablename = strdupW(MSI_standard_tables[i].tablename);
 872             colinfo[n].colname = strdupW(MSI_standard_tables[i].columnname);
 873             colinfo[n].number = MSI_standard_tables[i].number;
 874             colinfo[n].type = MSI_standard_tables[i].type;
 875             /* ERR("Table %s has column %s\n",debugstr_w(colinfo[n].tablename),
 876                     debugstr_w(colinfo[n].colname)); */
 877             if( n )
 878                 colinfo[n].offset = colinfo[n-1].offset
 879                                   + bytes_per_column( &colinfo[n-1] );
 880             else
 881                 colinfo[n].offset = 0;
 882         }
 883         n++;
 884         if( colinfo && (n >= *sz) )
 885             break;
 886     }
 887     *sz = n;
 888     return ERROR_SUCCESS;
 889 }
 890
 891 LPWSTR MSI_makestring( MSIDATABASE *db, UINT stringid)
 892 {
 893     UINT sz=0, r;
 894     LPWSTR str;
 895
 896     r = msi_id2stringW( db->strings, stringid, NULL, &sz );
 897     if( r != ERROR_SUCCESS )
 898         return NULL;
 899     str = HeapAlloc( GetProcessHeap(), 0, sz*sizeof (WCHAR));
 900     if( !str )
 901         return str;
 902     r = msi_id2stringW( db->strings, stringid, str, &sz );
 903     if( r == ERROR_SUCCESS )
 904         return str;
 905     HeapFree(  GetProcessHeap(), 0, str );
 906     return NULL;
 907 }
 908
 909 static UINT get_tablecolumns( MSIDATABASE *db,
 910        LPCWSTR szTableName, MSICOLUMNINFO *colinfo, UINT *sz)
 911 {
 912     UINT r, i, n=0, table_id, count, maxcount = *sz;
 913     MSITABLE *table = NULL;
 914     static const WCHAR szColumns[] = { '_','C','o','l','u','m','n','s',0 };
 915
 916     /* first check if there is a default table with that name */
 917     r = get_defaulttablecolumns( szTableName, colinfo, sz );
 918     if( ( r == ERROR_SUCCESS ) && *sz )
 919         return r;
 920
 921     r = get_table( db, szColumns, &table);
 922     if( r != ERROR_SUCCESS )
 923     {
 924         WARN("table %s not available\n", debugstr_w(szColumns));
 925         return r;
 926     }
 927
 928     /* convert table and column names to IDs from the string table */
 929     r = msi_string2idW( db->strings, szTableName, &table_id );
 930     if( r != ERROR_SUCCESS )
 931     {
 932         release_table( db, table );
 933         WARN("Couldn't find id for %s\n", debugstr_w(szTableName));
 934         return r;
 935     }
 936
 937     TRACE("Table id is %d\n", table_id);
 938
 939     count = table->row_count;
 940     for( i=0; i<count; i++ )
 941     {
 942         if( table->data[ i ][ 0 ] != table_id )
 943             continue;
 944         if( colinfo )
 945         {
 946             UINT id = table->data[ i ] [ 2 ];
 947             colinfo[n].tablename = MSI_makestring( db, table_id );
 948             colinfo[n].number = table->data[ i ][ 1 ] - (1<<15);
 949             colinfo[n].colname = MSI_makestring( db, id );
 950             colinfo[n].type = table->data[ i ] [ 3 ];
 951             /* this assumes that columns are in order in the table */
 952             if( n )
 953                 colinfo[n].offset = colinfo[n-1].offset
 954                                   + bytes_per_column( &colinfo[n-1] );
 955             else
 956                 colinfo[n].offset = 0;
 957             TRACE("table %s column %d is [%s] (%d) with type %08x "
 958                   "offset %d at row %d\n", debugstr_w(szTableName),
 959                    colinfo[n].number, debugstr_w(colinfo[n].colname),
 960                    id, colinfo[n].type, colinfo[n].offset, i);
 961             if( n != (colinfo[n].number-1) )
 962             {
 963                 ERR("oops. data in the _Columns table isn't in the right "
 964                     "order for table %s\n", debugstr_w(szTableName));
 965                 return ERROR_FUNCTION_FAILED;
 966             }
 967         }
 968         n++;
 969         if( colinfo && ( n >= maxcount ) )
 970             break;
 971     }
 972     *sz = n;
 973
 974     release_table( db, table );
 975
 976     return ERROR_SUCCESS;
 977 }
 978
 979 /* try to find the table name in the _Tables table */
 980 BOOL TABLE_Exists( MSIDATABASE *db, LPWSTR name )
 981 {
 982     static const WCHAR szTables[] = { '_','T','a','b','l','e','s',0 };
 983     static const WCHAR szColumns[] = { '_','C','o','l','u','m','n','s',0 };
 984     UINT r, table_id = 0, i, count;
 985     MSITABLE *table = NULL;
 986
 987     if( !lstrcmpW( name, szTables ) )
 988         return TRUE;
 989     if( !lstrcmpW( name, szColumns ) )
 990         return TRUE;
 991
 992     r = msi_string2idW( db->strings, name, &table_id );
 993     if( r != ERROR_SUCCESS )
 994     {
 995         TRACE("Couldn't find id for %s\n", debugstr_w(name));
 996         return FALSE;
 997     }
 998
 999     r = get_table( db, szTables, &table);
1000     if( r != ERROR_SUCCESS )
1001     {
1002         TRACE("table %s not available\n", debugstr_w(szTables));
1003         return FALSE;
1004     }
1005
1006     /* count = table->size/2; */
1007     count = table->row_count;
1008     for( i=0; i<count; i++ )
1009         if( table->data[ i ][ 0 ] == table_id )
1010             break;
1011
1012     release_table( db, table );
1013
1014     if (i!=count)
1015         return TRUE;
1016
1017     TRACE("Searched %d tables, but %d was not found\n", count, table_id );
1018
1019     return FALSE;
1020 }
1021
1022 /* below is the query interface to a table */
1023
1024 typedef struct tagMSITABLEVIEW
1025 {
1026     MSIVIEW        view;
1027     MSIDATABASE   *db;
1028     MSITABLE      *table;
1029     MSICOLUMNINFO *columns;
1030     UINT           num_cols;
1031     UINT           row_size;
1032     WCHAR          name[1];
1033 } MSITABLEVIEW;
1034
1035 static UINT TABLE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
1036 {
1037     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1038     UINT offset, num_rows, n;
1039
1040     if( !tv->table )
1041         return ERROR_INVALID_PARAMETER;
1042
1043     if( (col==0) || (col>tv->num_cols) )
1044         return ERROR_INVALID_PARAMETER;
1045
1046     /* how many rows are there ? */
1047     num_rows = tv->table->row_count;
1048     if( row >= num_rows )
1049         return ERROR_NO_MORE_ITEMS;
1050
1051     if( tv->columns[col-1].offset >= tv->row_size )
1052     {
1053         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1054         ERR("%p %p\n", tv, tv->columns );
1055         return ERROR_FUNCTION_FAILED;
1056     }
1057
1058     offset = row + (tv->columns[col-1].offset/2) * num_rows;
1059     n = bytes_per_column( &tv->columns[col-1] );
1060     switch( n )
1061     {
1062     case 4:
1063         offset = tv->columns[col-1].offset/2;
1064         *val = tv->table->data[row][offset] +
1065                (tv->table->data[row][offset + 1] << 16);
1066         break;
1067     case 2:
1068         offset = tv->columns[col-1].offset/2;
1069         *val = tv->table->data[row][offset];
1070         break;
1071     default:
1072         ERR("oops! what is %d bytes per column?\n", n );
1073         return ERROR_FUNCTION_FAILED;
1074     }
1075
1076     /* TRACE("Data [%d][%d] = %d \n", row, col, *val ); */
1077
1078     return ERROR_SUCCESS;
1079 }
1080
1081 /*
1082  * We need a special case for streams, as we need to reference column with
1083  * the name of the stream in the same table, and the table name
1084  * which may not be available at higher levels of the query
1085  */
1086 static UINT TABLE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
1087 {
1088     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1089     UINT ival = 0, refcol = 0, r;
1090     LPWSTR sval;
1091     LPWSTR full_name;
1092     DWORD len;
1093     static const WCHAR szDot[] = { '.', 0 };
1094
1095     if( !view->ops->fetch_int )
1096         return ERROR_INVALID_PARAMETER;
1097
1098     /*
1099      * The column marked with the type stream data seems to have a single number
1100      * which references the column containing the name of the stream data
1101      *
1102      * Fetch the column to reference first.
1103      */
1104     r = view->ops->fetch_int( view, row, col, &ival );
1105     if( r != ERROR_SUCCESS )
1106         return r;
1107
1108     /* now get the column with the name of the stream */
1109     r = view->ops->fetch_int( view, row, ival, &refcol );
1110     if( r != ERROR_SUCCESS )
1111         return r;
1112
1113     /* lookup the string value from the string table */
1114     sval = MSI_makestring( tv->db, refcol );
1115     if( !sval )
1116         return ERROR_INVALID_PARAMETER;
1117
1118     len = lstrlenW( tv->name ) + 2 + lstrlenW( sval );
1119     full_name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1120     lstrcpyW( full_name, tv->name );
1121     lstrcatW( full_name, szDot );
1122     lstrcatW( full_name, sval );
1123
1124     r = db_get_raw_stream( tv->db, full_name, stm );
1125     if( r )
1126         ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r);
1127     HeapFree( GetProcessHeap(), 0, full_name );
1128     HeapFree( GetProcessHeap(), 0, sval );
1129
1130     return r;
1131 }
1132
1133 static UINT TABLE_set_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT val )
1134 {
1135     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1136     UINT offset, n;
1137
1138     if( !tv->table )
1139         return ERROR_INVALID_PARAMETER;
1140
1141     if( (col==0) || (col>tv->num_cols) )
1142         return ERROR_INVALID_PARAMETER;
1143
1144     if( tv->columns[col-1].offset >= tv->row_size )
1145     {
1146         ERR("Stuffed up %d >= %d\n", tv->columns[col-1].offset, tv->row_size );
1147         ERR("%p %p\n", tv, tv->columns );
1148         return ERROR_FUNCTION_FAILED;
1149     }
1150
1151     n = bytes_per_column( &tv->columns[col-1] );
1152     switch( n )
1153     {
1154     case 4:
1155         offset = tv->columns[col-1].offset/2;
1156         tv->table->data[row][offset]     = val & 0xffff;
1157         tv->table->data[row][offset + 1] = (val>>16)&0xffff;
1158         break;
1159     case 2:
1160         offset = tv->columns[col-1].offset/2;
1161         tv->table->data[row][offset] = val;
1162         break;
1163     default:
1164         ERR("oops! what is %d bytes per column?\n", n );
1165         return ERROR_FUNCTION_FAILED;
1166     }
1167     return ERROR_SUCCESS;
1168 }
1169
1170 static UINT TABLE_insert_row( struct tagMSIVIEW *view, UINT *num )
1171 {
1172     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1173     USHORT **p, *row;
1174     UINT sz;
1175
1176     TRACE("%p\n", view);
1177
1178     if( !tv->table )
1179         return ERROR_INVALID_PARAMETER;
1180
1181     row = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, tv->row_size );
1182     if( !row )
1183         return ERROR_NOT_ENOUGH_MEMORY;
1184
1185     sz = (tv->table->row_count + 1) * sizeof (UINT*);
1186     if( tv->table->data )
1187         p = HeapReAlloc( GetProcessHeap(), 0, tv->table->data, sz );
1188     else
1189         p = HeapAlloc( GetProcessHeap(), 0, sz );
1190     if( !p )
1191     {
1192         HeapFree( GetProcessHeap(), 0, row );
1193         return ERROR_NOT_ENOUGH_MEMORY;
1194     }
1195
1196     tv->table->data = p;
1197     tv->table->data[tv->table->row_count] = row;
1198     *num = tv->table->row_count;
1199     tv->table->row_count++;
1200
1201     return ERROR_SUCCESS;
1202 }
1203
1204 static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
1205 {
1206     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1207     UINT r;
1208
1209     TRACE("%p %p\n", tv, record);
1210
1211     if( tv->table )
1212     {
1213         release_table( tv->db, tv->table );
1214         tv->table = NULL;
1215     }
1216
1217     r = get_table( tv->db, tv->name, &tv->table );
1218     if( r != ERROR_SUCCESS )
1219         return r;
1220
1221     return ERROR_SUCCESS;
1222 }
1223
1224 static UINT TABLE_close( struct tagMSIVIEW *view )
1225 {
1226     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1227
1228     TRACE("%p\n", view );
1229
1230     if( !tv->table )
1231         return ERROR_FUNCTION_FAILED;
1232
1233     release_table( tv->db, tv->table );
1234     tv->table = NULL;
1235
1236     return ERROR_SUCCESS;
1237 }
1238
1239 static UINT TABLE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols)
1240 {
1241     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1242
1243     TRACE("%p %p %p\n", view, rows, cols );
1244
1245     if( cols )
1246         *cols = tv->num_cols;
1247     if( rows )
1248     {
1249         if( !tv->table )
1250             return ERROR_INVALID_PARAMETER;
1251         *rows = tv->table->row_count;
1252     }
1253
1254     return ERROR_SUCCESS;
1255 }
1256
1257 static UINT TABLE_get_column_info( struct tagMSIVIEW *view,
1258                 UINT n, LPWSTR *name, UINT *type )
1259 {
1260     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1261
1262     TRACE("%p %d %p %p\n", tv, n, name, type );
1263
1264     if( ( n == 0 ) || ( n > tv->num_cols ) )
1265         return ERROR_INVALID_PARAMETER;
1266
1267     if( name )
1268     {
1269         *name = strdupW( tv->columns[n-1].colname );
1270         if( !*name )
1271             return ERROR_FUNCTION_FAILED;
1272     }
1273     if( type )
1274         *type = tv->columns[n-1].type;
1275
1276     return ERROR_SUCCESS;
1277 }
1278
1279 static UINT TABLE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
1280                 MSIRECORD *rec)
1281 {
1282     FIXME("%p %d %p\n", view, eModifyMode, rec );
1283     return ERROR_CALL_NOT_IMPLEMENTED;
1284 }
1285
1286 static UINT TABLE_delete( struct tagMSIVIEW *view )
1287 {
1288     MSITABLEVIEW *tv = (MSITABLEVIEW*)view;
1289
1290     TRACE("%p\n", view );
1291
1292     if( tv->table )
1293         release_table( tv->db, tv->table );
1294     tv->table = NULL;
1295
1296     if( tv->columns )
1297     {
1298         UINT i;
1299         for( i=0; i<tv->num_cols; i++)
1300         {
1301             HeapFree( GetProcessHeap(), 0, tv->columns[i].colname );
1302             HeapFree( GetProcessHeap(), 0, tv->columns[i].tablename );
1303         }
1304         HeapFree( GetProcessHeap(), 0, tv->columns );
1305     }
1306     tv->columns = NULL;
1307
1308     HeapFree( GetProcessHeap(), 0, tv );
1309
1310     return ERROR_SUCCESS;
1311 }
1312
1313
1314 MSIVIEWOPS table_ops =
1315 {
1316     TABLE_fetch_int,
1317     TABLE_fetch_stream,
1318     TABLE_set_int,
1319     TABLE_insert_row,
1320     TABLE_execute,
1321     TABLE_close,
1322     TABLE_get_dimensions,
1323     TABLE_get_column_info,
1324     TABLE_modify,
1325     TABLE_delete
1326 };
1327
1328 UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view )
1329 {
1330     MSITABLEVIEW *tv ;
1331     UINT r, sz, column_count;
1332     MSICOLUMNINFO *columns, *last_col;
1333
1334     TRACE("%p %s %p\n", db, debugstr_w(name), view );
1335
1336     /* get the number of columns in this table */
1337     column_count = 0;
1338     r = get_tablecolumns( db, name, NULL, &column_count );
1339     if( r != ERROR_SUCCESS )
1340         return r;
1341
1342     /* if there's no columns, there's no table */
1343     if( column_count == 0 )
1344         return ERROR_INVALID_PARAMETER;
1345
1346     TRACE("Table found\n");
1347
1348     sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ;
1349     tv = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sz );
1350     if( !tv )
1351         return ERROR_FUNCTION_FAILED;
1352
1353     columns = HeapAlloc( GetProcessHeap(), 0, column_count*sizeof (MSICOLUMNINFO));
1354     if( !columns )
1355     {
1356         HeapFree( GetProcessHeap(), 0, tv );
1357         return ERROR_FUNCTION_FAILED;
1358     }
1359
1360     r = get_tablecolumns( db, name, columns, &column_count );
1361     if( r != ERROR_SUCCESS )
1362     {
1363         HeapFree( GetProcessHeap(), 0, columns );
1364         HeapFree( GetProcessHeap(), 0, tv );
1365         return ERROR_FUNCTION_FAILED;
1366     }
1367
1368     TRACE("Table has %d columns\n", column_count);
1369
1370     last_col = &columns[column_count-1];
1371
1372     /* fill the structure */
1373     tv->view.ops = &table_ops;
1374     tv->db = db;
1375     tv->columns = columns;
1376     tv->num_cols = column_count;
1377     tv->table = NULL;
1378     tv->row_size = last_col->offset + bytes_per_column( last_col );
1379
1380     TRACE("one row is %d bytes\n", tv->row_size );
1381
1382     *view = (MSIVIEW*) tv;
1383     lstrcpyW( tv->name, name );
1384
1385     return ERROR_SUCCESS;
1386 }
1387
1388 UINT MSI_CommitTables( MSIDATABASE *db )
1389 {
1390     UINT r;
1391     MSITABLE *table = NULL;
1392
1393     TRACE("%p\n",db);
1394
1395     r = save_string_table( db );
1396     if( r != ERROR_SUCCESS )
1397     {
1398         WARN("failed to save string table r=%08x\n",r);
1399         return r;
1400     }
1401
1402     for( table = db->first_table; table; table = table->next )
1403     {
1404         r = save_table( db, table );
1405         if( r != ERROR_SUCCESS )
1406         {
1407             WARN("failed to save table %s (r=%08x)\n",
1408                   debugstr_w(table->name), r);
1409             return r;
1410         }
1411     }
1412
1413     /* force everything to reload next time */
1414     free_cached_tables( db );
1415
1416     return ERROR_SUCCESS;
1417 }