dlls/msi/database.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2002,2003,2004,2005 Mike McCormack for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "winnls.h"
  30 #include "wine/debug.h"
  31 #include "wine/unicode.h"
  32 #include "msi.h"
  33 #include "msiquery.h"
  34 #include "msipriv.h"
  35 #include "objidl.h"
  36 #include "objbase.h"
  37
  38 #include "initguid.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  41
  42 DEFINE_GUID( CLSID_MsiDatabase, 0x000c1084, 0x0000, 0x0000,
  43              0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  44 DEFINE_GUID( CLSID_MsiPatch, 0x000c1086, 0x0000, 0x0000,
  45              0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  46
  47 /*
  48  *  .MSI  file format
  49  *
  50  *  An .msi file is a structured storage file.
  51  *  It contains a number of streams.
  52  *  A stream for each table in the database.
  53  *  Two streams for the string table in the database.
  54  *  Any binary data in a table is a reference to a stream.
  55  */
  56
  57 static VOID MSI_CloseDatabase( MSIOBJECTHDR *arg )
  58 {
  59     MSIDATABASE *db = (MSIDATABASE *) arg;
  60
  61     msi_free(db->path);
  62     free_cached_tables( db );
  63     msi_free_transforms( db );
  64     msi_destroy_stringtable( db->strings );
  65     IStorage_Release( db->storage );
  66     if (db->deletefile)
  67     {
  68         DeleteFileW( db->deletefile );
  69         msi_free( db->deletefile );
  70     }
  71 }
  72
  73 UINT MSI_OpenDatabaseW(LPCWSTR szDBPath, LPCWSTR szPersist, MSIDATABASE **pdb)
  74 {
  75     IStorage *stg = NULL;
  76     HRESULT r;
  77     MSIDATABASE *db = NULL;
  78     UINT ret = ERROR_FUNCTION_FAILED;
  79     LPCWSTR szMode, save_path;
  80     STATSTG stat;
  81     BOOL created = FALSE;
  82     WCHAR path[MAX_PATH];
  83
  84     static const WCHAR backslash[] = {'\\',0};
  85
  86     TRACE("%s %s\n",debugstr_w(szDBPath),debugstr_w(szPersist) );
  87
  88     if( !pdb )
  89         return ERROR_INVALID_PARAMETER;
  90
  91     save_path = szDBPath;
  92     szMode = szPersist;
  93     if( HIWORD( szPersist ) )
  94     {
  95         if (!CopyFileW( szDBPath, szPersist, FALSE ))
  96             return ERROR_OPEN_FAILED;
  97
  98         szDBPath = szPersist;
  99         szPersist = MSIDBOPEN_TRANSACT;
 100         created = TRUE;
 101     }
 102
 103     if( szPersist == MSIDBOPEN_READONLY )
 104     {
 105         r = StgOpenStorage( szDBPath, NULL,
 106               STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 107     }
 108     else if( szPersist == MSIDBOPEN_CREATE || szPersist == MSIDBOPEN_CREATEDIRECT )
 109     {
 110         /* FIXME: MSIDBOPEN_CREATE should case STGM_TRANSACTED flag to be
 111          * used here: */
 112         r = StgCreateDocfile( szDBPath,
 113               STGM_CREATE|STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &stg);
 114         if( r == ERROR_SUCCESS )
 115         {
 116             IStorage_SetClass( stg, &CLSID_MsiDatabase );
 117             r = init_string_table( stg );
 118         }
 119         created = TRUE;
 120     }
 121     else if( szPersist == MSIDBOPEN_TRANSACT )
 122     {
 123         /* FIXME: MSIDBOPEN_TRANSACT should case STGM_TRANSACTED flag to be
 124          * used here: */
 125         r = StgOpenStorage( szDBPath, NULL,
 126               STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 127     }
 128     else if( szPersist == MSIDBOPEN_DIRECT )
 129     {
 130         r = StgOpenStorage( szDBPath, NULL,
 131               STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 132     }
 133     else
 134     {
 135         ERR("unknown flag %p\n",szPersist);
 136         return ERROR_INVALID_PARAMETER;
 137     }
 138
 139     if( FAILED( r ) )
 140     {
 141         FIXME("open failed r = %08x!\n",r);
 142         return ERROR_FUNCTION_FAILED;
 143     }
 144
 145     r = IStorage_Stat( stg, &stat, STATFLAG_NONAME );
 146     if( FAILED( r ) )
 147     {
 148         FIXME("Failed to stat storage\n");
 149         goto end;
 150     }
 151
 152     if ( !IsEqualGUID( &stat.clsid, &CLSID_MsiDatabase ) &&
 153          !IsEqualGUID( &stat.clsid, &CLSID_MsiPatch ) )
 154     {
 155         ERR("storage GUID is not a MSI database GUID %s\n",
 156              debugstr_guid(&stat.clsid) );
 157         goto end;
 158     }
 159
 160     db = alloc_msiobject( MSIHANDLETYPE_DATABASE, sizeof (MSIDATABASE),
 161                               MSI_CloseDatabase );
 162     if( !db )
 163     {
 164         FIXME("Failed to allocate a handle\n");
 165         goto end;
 166     }
 167
 168     if (!strchrW( save_path, '\\' ))
 169     {
 170         GetCurrentDirectoryW( MAX_PATH, path );
 171         lstrcatW( path, backslash );
 172         lstrcatW( path, save_path );
 173     }
 174     else
 175         lstrcpyW( path, save_path );
 176
 177     db->path = strdupW( path );
 178
 179     if( TRACE_ON( msi ) )
 180         enum_stream_names( stg );
 181
 182     db->storage = stg;
 183     db->mode = szMode;
 184     if (created)
 185         db->deletefile = strdupW( szDBPath );
 186     else
 187         db->deletefile = NULL;
 188     list_init( &db->tables );
 189     list_init( &db->transforms );
 190
 191     db->strings = load_string_table( stg );
 192     if( !db->strings )
 193         goto end;
 194
 195     ret = ERROR_SUCCESS;
 196
 197     msiobj_addref( &db->hdr );
 198     IStorage_AddRef( stg );
 199     *pdb = db;
 200
 201 end:
 202     if( db )
 203         msiobj_release( &db->hdr );
 204     if( stg )
 205         IStorage_Release( stg );
 206
 207     return ret;
 208 }
 209
 210 UINT WINAPI MsiOpenDatabaseW(LPCWSTR szDBPath, LPCWSTR szPersist, MSIHANDLE *phDB)
 211 {
 212     MSIDATABASE *db;
 213     UINT ret;
 214
 215     TRACE("%s %s %p\n",debugstr_w(szDBPath),debugstr_w(szPersist), phDB);
 216
 217     ret = MSI_OpenDatabaseW( szDBPath, szPersist, &db );
 218     if( ret == ERROR_SUCCESS )
 219     {
 220         *phDB = alloc_msihandle( &db->hdr );
 221         if (! *phDB)
 222             ret = ERROR_NOT_ENOUGH_MEMORY;
 223         msiobj_release( &db->hdr );
 224     }
 225
 226     return ret;
 227 }
 228
 229 UINT WINAPI MsiOpenDatabaseA(LPCSTR szDBPath, LPCSTR szPersist, MSIHANDLE *phDB)
 230 {
 231     HRESULT r = ERROR_FUNCTION_FAILED;
 232     LPWSTR szwDBPath = NULL, szwPersist = NULL;
 233
 234     TRACE("%s %s %p\n", debugstr_a(szDBPath), debugstr_a(szPersist), phDB);
 235
 236     if( szDBPath )
 237     {
 238         szwDBPath = strdupAtoW( szDBPath );
 239         if( !szwDBPath )
 240             goto end;
 241     }
 242
 243     if( HIWORD(szPersist) )
 244     {
 245         szwPersist = strdupAtoW( szPersist );
 246         if( !szwPersist )
 247             goto end;
 248     }
 249     else
 250         szwPersist = (LPWSTR)(DWORD_PTR)szPersist;
 251
 252     r = MsiOpenDatabaseW( szwDBPath, szwPersist, phDB );
 253
 254 end:
 255     if( HIWORD(szPersist) )
 256         msi_free( szwPersist );
 257     msi_free( szwDBPath );
 258
 259     return r;
 260 }
 261
 262 static LPWSTR msi_read_text_archive(LPCWSTR path)
 263 {
 264     HANDLE file;
 265     LPSTR data = NULL;
 266     LPWSTR wdata = NULL;
 267     DWORD read, size = 0;
 268
 269     file = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
 270     if (file == INVALID_HANDLE_VALUE)
 271         return NULL;
 272
 273     size = GetFileSize( file, NULL );
 274     data = msi_alloc( size + 1 );
 275     if (!data)
 276         goto done;
 277
 278     if (!ReadFile( file, data, size, &read, NULL ))
 279         goto done;
 280
 281     data[size] = '\0';
 282     wdata = strdupAtoW( data );
 283
 284 done:
 285     CloseHandle( file );
 286     msi_free( data );
 287     return wdata;
 288 }
 289
 290 static void msi_parse_line(LPWSTR *line, LPWSTR **entries, DWORD *num_entries)
 291 {
 292     LPWSTR ptr = *line, save;
 293     DWORD i, count = 1;
 294
 295     *entries = NULL;
 296
 297     /* stay on this line */
 298     while (*ptr && *ptr != '\n')
 299     {
 300         /* entries are separated by tabs */
 301         if (*ptr == '\t')
 302             count++;
 303
 304         ptr++;
 305     }
 306
 307     *entries = msi_alloc(count * sizeof(LPWSTR));
 308     if (!*entries)
 309         return;
 310
 311     /* store pointers into the data */
 312     for (i = 0, ptr = *line; i < count; i++)
 313     {
 314         save = ptr;
 315
 316         while (*ptr && *ptr != '\t' && *ptr != '\n') ptr++;
 317
 318         /* NULL-separate the data */
 319         if (*ptr)
 320             *ptr++ = '\0';
 321
 322         (*entries)[i] = save;
 323     }
 324
 325     /* move to the next line if there's more, else EOF */
 326     *line = ptr;
 327
 328     if (num_entries)
 329         *num_entries = count;
 330 }
 331
 332 static LPWSTR msi_build_createsql_prelude(LPWSTR table)
 333 {
 334     LPWSTR prelude;
 335     DWORD size;
 336
 337     static const WCHAR create_fmt[] = {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','%','s','`',' ','(',' ',0};
 338
 339     size = sizeof(create_fmt) + lstrlenW(table) - 2;
 340     prelude = msi_alloc(size * sizeof(WCHAR));
 341     if (!prelude)
 342         return NULL;
 343
 344     sprintfW(prelude, create_fmt, table);
 345     return prelude;
 346 }
 347
 348 static LPWSTR msi_build_createsql_columns(LPWSTR *columns_data, LPWSTR *types, DWORD num_columns)
 349 {
 350     LPWSTR columns;
 351     LPCWSTR type;
 352     DWORD sql_size = 1, i, len;
 353     WCHAR expanded[128], *ptr;
 354     WCHAR size[10], comma[2], extra[30];
 355
 356     static const WCHAR column_fmt[] = {'`','%','s','`',' ','%','s','%','s','%','s','%','s',' ',0};
 357     static const WCHAR size_fmt[] = {'(','%','s',')',0};
 358     static const WCHAR type_char[] = {'C','H','A','R',0};
 359     static const WCHAR type_int[] = {'I','N','T',0};
 360     static const WCHAR type_long[] = {'L','O','N','G',0};
 361     static const WCHAR type_notnull[] = {' ','N','O','T',' ','N','U','L','L',0};
 362     static const WCHAR localizable[] = {' ','L','O','C','A','L','I','Z','A','B','L','E',0};
 363
 364     columns = msi_alloc_zero(sql_size * sizeof(WCHAR));
 365     if (!columns)
 366         return NULL;
 367
 368     for (i = 0; i < num_columns; i++)
 369     {
 370         type = NULL;
 371         comma[1] = size[0] = extra[0] = '\0';
 372
 373         if (i == num_columns - 1)
 374             comma[0] = '\0';
 375         else
 376             comma[0] = ',';
 377
 378         ptr = &types[i][1];
 379         len = atolW(ptr);
 380         extra[0] = '\0';
 381
 382         switch (types[i][0])
 383         {
 384             case 'l':
 385                 lstrcpyW(extra, type_notnull);
 386             case 'L':
 387                 lstrcatW(extra, localizable);
 388                 type = type_char;
 389                 sprintfW(size, size_fmt, ptr);
 390                 break;
 391             case 's':
 392                 lstrcpyW(extra, type_notnull);
 393             case 'S':
 394                 type = type_char;
 395                 sprintfW(size, size_fmt, ptr);
 396                 break;
 397             case 'i':
 398                 lstrcpyW(extra, type_notnull);
 399             case 'I':
 400                 if (len == 2)
 401                     type = type_int;
 402                 else
 403                     type = type_long;
 404                 break;
 405         }
 406
 407         sprintfW(expanded, column_fmt, columns_data[i], type, size, extra, comma);
 408         sql_size += lstrlenW(expanded);
 409
 410         columns = msi_realloc(columns, sql_size * sizeof(WCHAR));
 411         if (!columns)
 412             return NULL;
 413
 414         lstrcatW(columns, expanded);
 415     }
 416
 417     return columns;
 418 }
 419
 420 static LPWSTR msi_build_createsql_postlude(LPWSTR *primary_keys, DWORD num_keys)
 421 {
 422     LPWSTR postlude, keys, ptr;
 423     DWORD size, key_size, i;
 424
 425     static const WCHAR key_fmt[] = {'`','%','s','`',',',' ',0};
 426     static const WCHAR postlude_fmt[] = {'P','R','I','M','A','R','Y',' ','K','E','Y',' ','%','s',')',' ','H','O','L','D',0};
 427
 428     for (i = 0, size = 1; i < num_keys; i++)
 429         size += lstrlenW(key_fmt) + lstrlenW(primary_keys[i]) - 2;
 430
 431     keys = msi_alloc(size * sizeof(WCHAR));
 432     if (!keys)
 433         return NULL;
 434
 435     for (i = 0, ptr = keys; i < num_keys; i++)
 436     {
 437         key_size = lstrlenW(key_fmt) + lstrlenW(primary_keys[i]) -2;
 438         sprintfW(ptr, key_fmt, primary_keys[i]);
 439         ptr += key_size;
 440     }
 441
 442     /* remove final ', ' */
 443     *(ptr - 2) = '\0';
 444
 445     size = lstrlenW(postlude_fmt) + size - 1;
 446     postlude = msi_alloc(size * sizeof(WCHAR));
 447     if (!postlude)
 448         goto done;
 449
 450     sprintfW(postlude, postlude_fmt, keys);
 451
 452 done:
 453     msi_free(keys);
 454     return postlude;
 455 }
 456
 457 static UINT msi_add_table_to_db(MSIDATABASE *db, LPWSTR *columns, LPWSTR *types, LPWSTR *labels, DWORD num_labels, DWORD num_columns)
 458 {
 459     UINT r;
 460     DWORD size;
 461     MSIQUERY *view;
 462     LPWSTR create_sql;
 463     LPWSTR prelude, columns_sql, postlude;
 464
 465     prelude = msi_build_createsql_prelude(labels[0]);
 466     columns_sql = msi_build_createsql_columns(columns, types, num_columns);
 467     postlude = msi_build_createsql_postlude(labels + 1, num_labels - 1); /* skip over table name */
 468
 469     if (!prelude || !columns_sql || !postlude)
 470         return ERROR_OUTOFMEMORY;
 471
 472     size = lstrlenW(prelude) + lstrlenW(columns_sql) + lstrlenW(postlude) + 1;
 473     create_sql = msi_alloc(size * sizeof(WCHAR));
 474     if (!create_sql)
 475         return ERROR_OUTOFMEMORY;
 476
 477     lstrcpyW(create_sql, prelude);
 478     lstrcatW(create_sql, columns_sql);
 479     lstrcatW(create_sql, postlude);
 480
 481     msi_free(prelude);
 482     msi_free(columns_sql);
 483     msi_free(postlude);
 484
 485     r = MSI_DatabaseOpenViewW( db, create_sql, &view );
 486     msi_free(create_sql);
 487
 488     if (r != ERROR_SUCCESS)
 489         return r;
 490
 491     r = MSI_ViewExecute(view, NULL);
 492     MSI_ViewClose(view);
 493     msiobj_release(&view->hdr);
 494
 495     return r;
 496 }
 497
 498 static LPWSTR msi_build_insertsql_prelude(LPWSTR table)
 499 {
 500     LPWSTR prelude;
 501     DWORD size;
 502
 503     static const WCHAR insert_fmt[] = {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','%','s','`',' ','(',' ',0};
 504
 505     size = sizeof(insert_fmt) + lstrlenW(table) - 2;
 506     prelude = msi_alloc(size * sizeof(WCHAR));
 507     if (!prelude)
 508         return NULL;
 509
 510     sprintfW(prelude, insert_fmt, table);
 511     return prelude;
 512 }
 513
 514 static LPWSTR msi_build_insertsql_columns(LPWSTR *columns_data, LPWSTR *types, DWORD num_columns)
 515 {
 516     LPWSTR columns;
 517     DWORD sql_size = 1, i;
 518     WCHAR expanded[128];
 519
 520     static const WCHAR column_fmt[] =  {'`','%','s','`',',',' ',0};
 521
 522     columns = msi_alloc_zero(sql_size * sizeof(WCHAR));
 523     if (!columns)
 524         return NULL;
 525
 526     for (i = 0; i < num_columns; i++)
 527     {
 528         sprintfW(expanded, column_fmt, columns_data[i]);
 529         sql_size += lstrlenW(expanded);
 530
 531         if (i == num_columns - 1)
 532         {
 533             sql_size -= 2;
 534             expanded[lstrlenW(expanded) - 2] = '\0';
 535         }
 536
 537         columns = msi_realloc(columns, sql_size * sizeof(WCHAR));
 538         if (!columns)
 539             return NULL;
 540
 541         lstrcatW(columns, expanded);
 542     }
 543
 544     return columns;
 545 }
 546
 547 static LPWSTR msi_build_insertsql_data(LPWSTR **records, LPWSTR *types, DWORD num_columns, DWORD irec)
 548 {
 549     LPWSTR columns;
 550     DWORD sql_size = 1, i;
 551     WCHAR expanded[128];
 552
 553     static const WCHAR str_fmt[] = {'\'','%','s','\'',',',' ',0};
 554     static const WCHAR int_fmt[] = {'%','s',',',' ',0};
 555     static const WCHAR empty[] = {'\'','\'',',',' ',0};
 556
 557     columns = msi_alloc_zero(sql_size * sizeof(WCHAR));
 558     if (!columns)
 559         return NULL;
 560
 561     for (i = 0; i < num_columns; i++)
 562     {
 563         switch (types[i][0])
 564         {
 565             case 'L': case 'l': case 'S': case 's':
 566                 sprintfW(expanded, str_fmt, records[irec][i]);
 567                 break;
 568             case 'I': case 'i':
 569                 if (*records[0][i])
 570                     sprintfW(expanded, int_fmt, records[irec][i]);
 571                 else
 572                     lstrcpyW(expanded, empty);
 573                 break;
 574             default:
 575                 return NULL;
 576         }
 577
 578         if (i == num_columns - 1)
 579             expanded[lstrlenW(expanded) - 2] = '\0';
 580
 581         sql_size += lstrlenW(expanded);
 582         columns = msi_realloc(columns, sql_size * sizeof(WCHAR));
 583         if (!columns)
 584             return NULL;
 585
 586         lstrcatW(columns, expanded);
 587     }
 588
 589     return columns;
 590 }
 591
 592 static UINT msi_add_records_to_table(MSIDATABASE *db, LPWSTR *columns, LPWSTR *types,
 593                                      LPWSTR *labels, LPWSTR **records,
 594                                      int num_columns, int num_records)
 595 {
 596     MSIQUERY *view;
 597     LPWSTR insert_sql;
 598     DWORD size, i;
 599     UINT r = ERROR_SUCCESS;
 600
 601     static const WCHAR mid[] = {' ',')',' ','V','A','L','U','E','S',' ','(',' ',0};
 602     static const WCHAR end[] = {' ',')',0};
 603
 604     LPWSTR prelude = msi_build_insertsql_prelude(labels[0]);
 605     LPWSTR columns_sql = msi_build_insertsql_columns(columns, types, num_columns);
 606
 607     for (i = 0; i < num_records; i++)
 608     {
 609         LPWSTR data = msi_build_insertsql_data(records, types, num_columns, i);
 610
 611         size = lstrlenW(prelude) + lstrlenW(columns_sql) + sizeof(mid) + lstrlenW(data) + sizeof(end) - 1;
 612         insert_sql = msi_alloc(size * sizeof(WCHAR));
 613         if (!insert_sql)
 614             return ERROR_OUTOFMEMORY;
 615
 616         lstrcpyW(insert_sql, prelude);
 617         lstrcatW(insert_sql, columns_sql);
 618         lstrcatW(insert_sql, mid);
 619         lstrcatW(insert_sql, data);
 620         lstrcatW(insert_sql, end);
 621
 622         msi_free(data);
 623
 624         r = MSI_DatabaseOpenViewW( db, insert_sql, &view );
 625         msi_free(insert_sql);
 626
 627         if (r != ERROR_SUCCESS)
 628             goto done;
 629
 630         r = MSI_ViewExecute(view, NULL);
 631         MSI_ViewClose(view);
 632         msiobj_release(&view->hdr);
 633     }
 634
 635 done:
 636     msi_free(prelude);
 637     msi_free(columns_sql);
 638
 639     return r;
 640 }
 641
 642 UINT MSI_DatabaseImport(MSIDATABASE *db, LPCWSTR folder, LPCWSTR file)
 643 {
 644     UINT r;
 645     DWORD len, i;
 646     DWORD num_labels;
 647     DWORD num_columns, num_records = 0;
 648     LPWSTR *columns, *types, *labels;
 649     LPWSTR path, ptr, data;
 650     LPWSTR **records;
 651
 652     static const WCHAR backslash[] = {'\\',0};
 653
 654     TRACE("%p %s %s\n", db, debugstr_w(folder), debugstr_w(file) );
 655
 656     if( folder == NULL || file == NULL )
 657         return ERROR_INVALID_PARAMETER;
 658
 659     len = lstrlenW(folder) + lstrlenW(backslash) + lstrlenW(file) + 1;
 660     path = msi_alloc( len * sizeof(WCHAR) );
 661     if (!path)
 662         return ERROR_OUTOFMEMORY;
 663
 664     lstrcpyW( path, folder );
 665     lstrcatW( path, backslash );
 666     lstrcatW( path, file );
 667
 668     data = msi_read_text_archive( path );
 669
 670     ptr = data;
 671     msi_parse_line( &ptr, &columns, &num_columns );
 672     msi_parse_line( &ptr, &types, NULL );
 673     msi_parse_line( &ptr, &labels, &num_labels );
 674
 675     records = msi_alloc(sizeof(LPWSTR *));
 676     if (!records)
 677         return ERROR_OUTOFMEMORY;
 678
 679     /* read in the table records */
 680     while (*ptr)
 681     {
 682         msi_parse_line( &ptr, &records[num_records], NULL );
 683
 684         num_records++;
 685         records = msi_realloc(records, (num_records + 1) * sizeof(LPWSTR *));
 686         if (!records)
 687             return ERROR_OUTOFMEMORY;
 688     }
 689
 690     r = msi_add_table_to_db( db, columns, types, labels, num_labels, num_columns );
 691     if (r != ERROR_SUCCESS)
 692         goto done;
 693
 694     r = msi_add_records_to_table( db, columns, types, labels, records, num_columns, num_records );
 695
 696 done:
 697     msi_free(path);
 698     msi_free(data);
 699     msi_free(columns);
 700     msi_free(types);
 701     msi_free(labels);
 702
 703     for (i = 0; i < num_records; i++)
 704         msi_free(records[i]);
 705
 706     msi_free(records);
 707
 708     return r;
 709 }
 710
 711 UINT WINAPI MsiDatabaseImportW(MSIHANDLE handle, LPCWSTR szFolder, LPCWSTR szFilename)
 712 {
 713     MSIDATABASE *db;
 714     UINT r;
 715
 716     TRACE("%lx %s %s\n",handle,debugstr_w(szFolder), debugstr_w(szFilename));
 717
 718     db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
 719     if( !db )
 720         return ERROR_INVALID_HANDLE;
 721     r = MSI_DatabaseImport( db, szFolder, szFilename );
 722     msiobj_release( &db->hdr );
 723     return r;
 724 }
 725
 726 UINT WINAPI MsiDatabaseImportA( MSIHANDLE handle,
 727                LPCSTR szFolder, LPCSTR szFilename )
 728 {
 729     LPWSTR path = NULL, file = NULL;
 730     UINT r = ERROR_OUTOFMEMORY;
 731
 732     TRACE("%lx %s %s\n", handle, debugstr_a(szFolder), debugstr_a(szFilename));
 733
 734     if( szFolder )
 735     {
 736         path = strdupAtoW( szFolder );
 737         if( !path )
 738             goto end;
 739     }
 740
 741     if( szFilename )
 742     {
 743         file = strdupAtoW( szFilename );
 744         if( !file )
 745             goto end;
 746     }
 747
 748     r = MsiDatabaseImportW( handle, path, file );
 749
 750 end:
 751     msi_free( path );
 752     msi_free( file );
 753
 754     return r;
 755 }
 756
 757 static UINT msi_export_record( HANDLE handle, MSIRECORD *row, UINT start )
 758 {
 759     UINT i, count, len, r = ERROR_SUCCESS;
 760     const char *sep;
 761     char *buffer;
 762     DWORD sz;
 763
 764     len = 0x100;
 765     buffer = msi_alloc( len );
 766     if ( !buffer )
 767         return ERROR_OUTOFMEMORY;
 768
 769     count = MSI_RecordGetFieldCount( row );
 770     for ( i=start; i<=count; i++ )
 771     {
 772         sz = len;
 773         r = MSI_RecordGetStringA( row, i, buffer, &sz );
 774         if (r == ERROR_MORE_DATA)
 775         {
 776             char *p = msi_realloc( buffer, sz + 1 );
 777             if (!p)
 778                 break;
 779             len = sz + 1;
 780             buffer = p;
 781         }
 782         sz = len;
 783         r = MSI_RecordGetStringA( row, i, buffer, &sz );
 784         if (r != ERROR_SUCCESS)
 785             break;
 786
 787         if (!WriteFile( handle, buffer, sz, &sz, NULL ))
 788         {
 789             r = ERROR_FUNCTION_FAILED;
 790             break;
 791         }
 792
 793         sep = (i < count) ? "\t" : "\r\n";
 794         if (!WriteFile( handle, sep, strlen(sep), &sz, NULL ))
 795         {
 796             r = ERROR_FUNCTION_FAILED;
 797             break;
 798         }
 799     }
 800     msi_free( buffer );
 801     return r;
 802 }
 803
 804 static UINT msi_export_row( MSIRECORD *row, void *arg )
 805 {
 806     return msi_export_record( arg, row, 1 );
 807 }
 808
 809 UINT MSI_DatabaseExport( MSIDATABASE *db, LPCWSTR table,
 810                LPCWSTR folder, LPCWSTR file )
 811 {
 812     static const WCHAR query[] = {
 813         's','e','l','e','c','t',' ','*',' ','f','r','o','m',' ','%','s',0 };
 814     static const WCHAR szbs[] = { '\\', 0 };
 815     MSIRECORD *rec = NULL;
 816     MSIQUERY *view = NULL;
 817     LPWSTR filename;
 818     HANDLE handle;
 819     UINT len, r;
 820
 821     TRACE("%p %s %s %s\n", db, debugstr_w(table),
 822           debugstr_w(folder), debugstr_w(file) );
 823
 824     if( folder == NULL || file == NULL )
 825         return ERROR_INVALID_PARAMETER;
 826
 827     len = lstrlenW(folder) + lstrlenW(file) + 2;
 828     filename = msi_alloc(len * sizeof (WCHAR));
 829     if (!filename)
 830         return ERROR_OUTOFMEMORY;
 831
 832     lstrcpyW( filename, folder );
 833     lstrcatW( filename, szbs );
 834     lstrcatW( filename, file );
 835
 836     handle = CreateFileW( filename, GENERIC_READ | GENERIC_WRITE, 0,
 837                           NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
 838     msi_free( filename );
 839     if (handle == INVALID_HANDLE_VALUE)
 840         return ERROR_FUNCTION_FAILED;
 841
 842     r = MSI_OpenQuery( db, &view, query, table );
 843     if (r == ERROR_SUCCESS)
 844     {
 845         /* write out row 1, the column names */
 846         r = MSI_ViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
 847         if (r == ERROR_SUCCESS)
 848         {
 849             msi_export_record( handle, rec, 1 );
 850             msiobj_release( &rec->hdr );
 851         }
 852
 853         /* write out row 2, the column types */
 854         r = MSI_ViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
 855         if (r == ERROR_SUCCESS)
 856         {
 857             msi_export_record( handle, rec, 1 );
 858             msiobj_release( &rec->hdr );
 859         }
 860
 861         /* write out row 3, the table name + keys */
 862         r = MSI_DatabaseGetPrimaryKeys( db, table, &rec );
 863         if (r == ERROR_SUCCESS)
 864         {
 865             MSI_RecordSetStringW( rec, 0, table );
 866             msi_export_record( handle, rec, 0 );
 867             msiobj_release( &rec->hdr );
 868         }
 869
 870         /* write out row 4 onwards, the data */
 871         r = MSI_IterateRecords( view, 0, msi_export_row, handle );
 872         msiobj_release( &view->hdr );
 873     }
 874
 875     CloseHandle( handle );
 876
 877     return r;
 878 }
 879
 880 /***********************************************************************
 881  * MsiExportDatabaseW        [MSI.@]
 882  *
 883  * Writes a file containing the table data as tab separated ASCII.
 884  *
 885  * The format is as follows:
 886  *
 887  * row1 : colname1 <tab> colname2 <tab> .... colnameN <cr> <lf>
 888  * row2 : coltype1 <tab> coltype2 <tab> .... coltypeN <cr> <lf>
 889  * row3 : tablename <tab> key1 <tab> key2 <tab> ... keyM <cr> <lf>
 890  *
 891  * Followed by the data, starting at row 1 with one row per line
 892  *
 893  * row4 : data <tab> data <tab> data <tab> ... data <cr> <lf>
 894  */
 895 UINT WINAPI MsiDatabaseExportW( MSIHANDLE handle, LPCWSTR szTable,
 896                LPCWSTR szFolder, LPCWSTR szFilename )
 897 {
 898     MSIDATABASE *db;
 899     UINT r;
 900
 901     TRACE("%lx %s %s %s\n", handle, debugstr_w(szTable),
 902           debugstr_w(szFolder), debugstr_w(szFilename));
 903
 904     db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
 905     if( !db )
 906         return ERROR_INVALID_HANDLE;
 907     r = MSI_DatabaseExport( db, szTable, szFolder, szFilename );
 908     msiobj_release( &db->hdr );
 909     return r;
 910 }
 911
 912 UINT WINAPI MsiDatabaseExportA( MSIHANDLE handle, LPCSTR szTable,
 913                LPCSTR szFolder, LPCSTR szFilename )
 914 {
 915     LPWSTR path = NULL, file = NULL, table = NULL;
 916     UINT r = ERROR_OUTOFMEMORY;
 917
 918     TRACE("%lx %s %s %s\n", handle, debugstr_a(szTable),
 919           debugstr_a(szFolder), debugstr_a(szFilename));
 920
 921     if( szTable )
 922     {
 923         table = strdupAtoW( szTable );
 924         if( !table )
 925             goto end;
 926     }
 927
 928     if( szFolder )
 929     {
 930         path = strdupAtoW( szFolder );
 931         if( !path )
 932             goto end;
 933     }
 934
 935     if( szFilename )
 936     {
 937         file = strdupAtoW( szFilename );
 938         if( !file )
 939             goto end;
 940     }
 941
 942     r = MsiDatabaseExportW( handle, table, path, file );
 943
 944 end:
 945     msi_free( table );
 946     msi_free( path );
 947     msi_free( file );
 948
 949     return r;
 950 }
 951
 952 MSIDBSTATE WINAPI MsiGetDatabaseState( MSIHANDLE handle )
 953 {
 954     MSIDBSTATE ret = MSIDBSTATE_READ;
 955     MSIDATABASE *db;
 956
 957     TRACE("%ld\n", handle);
 958
 959     db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
 960     if (!db)
 961         return MSIDBSTATE_ERROR;
 962     if (db->mode != MSIDBOPEN_READONLY )
 963         ret = MSIDBSTATE_WRITE;
 964     msiobj_release( &db->hdr );
 965
 966     return ret;
 967 }