dll/win32/msi/streams.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2007 James Hawkins
   5  * Copyright 2015 Hans Leidekker for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "msipriv.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
  25
  26 #define NUM_STREAMS_COLS    2
  27
  28 typedef struct tagMSISTREAMSVIEW
  29 {
  30     MSIVIEW view;
  31     MSIDATABASE *db;
  32     UINT num_cols;
  33 } MSISTREAMSVIEW;
  34
  35 static BOOL streams_resize_table( MSIDATABASE *db, UINT size )
  36 {
  37     if (!db->num_streams_allocated)
  38     {
  39         if (!(db->streams = msi_alloc_zero( size * sizeof(MSISTREAM) ))) return FALSE;
  40         db->num_streams_allocated = size;
  41         return TRUE;
  42     }
  43     while (size >= db->num_streams_allocated)
  44     {
  45         MSISTREAM *tmp;
  46         UINT new_size = db->num_streams_allocated * 2;
  47         if (!(tmp = msi_realloc_zero( db->streams, new_size * sizeof(MSISTREAM) ))) return FALSE;
  48         db->streams = tmp;
  49         db->num_streams_allocated = new_size;
  50     }
  51     return TRUE;
  52 }
  53
  54 static UINT STREAMS_fetch_int(struct tagMSIVIEW *view, UINT row, UINT col, UINT *val)
  55 {
  56     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
  57
  58     TRACE("(%p, %d, %d, %p)\n", view, row, col, val);
  59
  60     if (col != 1)
  61         return ERROR_INVALID_PARAMETER;
  62
  63     if (row >= sv->db->num_streams)
  64         return ERROR_NO_MORE_ITEMS;
  65
  66     *val = sv->db->streams[row].str_index;
  67
  68     return ERROR_SUCCESS;
  69 }
  70
  71 static UINT STREAMS_fetch_stream(struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm)
  72 {
  73     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
  74     LARGE_INTEGER pos;
  75     HRESULT hr;
  76
  77     TRACE("(%p, %d, %d, %p)\n", view, row, col, stm);
  78
  79     if (row >= sv->db->num_streams)
  80         return ERROR_FUNCTION_FAILED;
  81
  82     pos.QuadPart = 0;
  83     hr = IStream_Seek( sv->db->streams[row].stream, pos, STREAM_SEEK_SET, NULL );
  84     if (FAILED( hr ))
  85         return ERROR_FUNCTION_FAILED;
  86
  87     *stm = sv->db->streams[row].stream;
  88     IStream_AddRef( *stm );
  89
  90     return ERROR_SUCCESS;
  91 }
  92
  93 static UINT STREAMS_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec )
  94 {
  95     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
  96
  97     TRACE("%p %d %p\n", sv, row, rec);
  98
  99     return msi_view_get_row( sv->db, view, row, rec );
 100 }
 101
 102 static UINT STREAMS_set_row(struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask)
 103 {
 104     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 105
 106     TRACE("(%p, %d, %p, %08x)\n", view, row, rec, mask);
 107
 108     if (row > sv->db->num_streams || mask >= (1 << sv->num_cols))
 109         return ERROR_INVALID_PARAMETER;
 110
 111     if (mask & 1)
 112     {
 113         const WCHAR *name = MSI_RecordGetString( rec, 1 );
 114
 115         if (!name) return ERROR_INVALID_PARAMETER;
 116         sv->db->streams[row].str_index = msi_add_string( sv->db->strings, name, -1, StringNonPersistent );
 117     }
 118     if (mask & 2)
 119     {
 120         IStream *old, *new;
 121         HRESULT hr;
 122         UINT r;
 123
 124         r = MSI_RecordGetIStream( rec, 2, &new );
 125         if (r != ERROR_SUCCESS)
 126             return r;
 127
 128         old = sv->db->streams[row].stream;
 129         hr = IStream_QueryInterface( new, &IID_IStream, (void **)&sv->db->streams[row].stream );
 130         if (FAILED( hr ))
 131         {
 132             IStream_Release( new );
 133             return ERROR_FUNCTION_FAILED;
 134         }
 135         if (old) IStream_Release( old );
 136     }
 137
 138     return ERROR_SUCCESS;
 139 }
 140
 141 static UINT streams_find_row( MSISTREAMSVIEW *sv, MSIRECORD *rec, UINT *row )
 142 {
 143     const WCHAR *str;
 144     UINT r, i, id, val;
 145
 146     str = MSI_RecordGetString( rec, 1 );
 147     r = msi_string2id( sv->db->strings, str, -1, &id );
 148     if (r != ERROR_SUCCESS)
 149         return r;
 150
 151     for (i = 0; i < sv->db->num_streams; i++)
 152     {
 153         STREAMS_fetch_int( &sv->view, i, 1, &val );
 154
 155         if (val == id)
 156         {
 157             if (row) *row = i;
 158             return ERROR_SUCCESS;
 159         }
 160     }
 161
 162     return ERROR_FUNCTION_FAILED;
 163 }
 164
 165 static UINT STREAMS_insert_row(struct tagMSIVIEW *view, MSIRECORD *rec, UINT row, BOOL temporary)
 166 {
 167     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 168     UINT i, r, num_rows = sv->db->num_streams + 1;
 169
 170     TRACE("(%p, %p, %d, %d)\n", view, rec, row, temporary);
 171
 172     r = streams_find_row( sv, rec, NULL );
 173     if (r == ERROR_SUCCESS)
 174         return ERROR_FUNCTION_FAILED;
 175
 176     if (!streams_resize_table( sv->db, num_rows ))
 177         return ERROR_FUNCTION_FAILED;
 178
 179     if (row == -1)
 180         row = num_rows - 1;
 181
 182     /* shift the rows to make room for the new row */
 183     for (i = num_rows - 1; i > row; i--)
 184     {
 185         sv->db->streams[i] = sv->db->streams[i - 1];
 186     }
 187
 188     r = STREAMS_set_row( view, row, rec, (1 << sv->num_cols) - 1 );
 189     if (r == ERROR_SUCCESS)
 190         sv->db->num_streams = num_rows;
 191
 192     return r;
 193 }
 194
 195 static UINT STREAMS_delete_row(struct tagMSIVIEW *view, UINT row)
 196 {
 197     MSIDATABASE *db = ((MSISTREAMSVIEW *)view)->db;
 198     UINT i, num_rows = db->num_streams - 1;
 199     const WCHAR *name;
 200     WCHAR *encname;
 201     HRESULT hr;
 202
 203     TRACE("(%p %d)!\n", view, row);
 204
 205     name = msi_string_lookup( db->strings, db->streams[row].str_index, NULL );
 206     if (!(encname = encode_streamname( FALSE, name ))) return ERROR_OUTOFMEMORY;
 207     hr = IStorage_DestroyElement( db->storage, encname );
 208     msi_free( encname );
 209     if (FAILED( hr ))
 210         return ERROR_FUNCTION_FAILED;
 211     hr = IStream_Release( db->streams[row].stream );
 212     if (FAILED( hr ))
 213         return ERROR_FUNCTION_FAILED;
 214
 215     for (i = row; i < num_rows; i++)
 216         db->streams[i] = db->streams[i + 1];
 217     db->num_streams = num_rows;
 218
 219     return ERROR_SUCCESS;
 220 }
 221
 222 static UINT STREAMS_execute(struct tagMSIVIEW *view, MSIRECORD *record)
 223 {
 224     TRACE("(%p, %p)\n", view, record);
 225     return ERROR_SUCCESS;
 226 }
 227
 228 static UINT STREAMS_close(struct tagMSIVIEW *view)
 229 {
 230     TRACE("(%p)\n", view);
 231     return ERROR_SUCCESS;
 232 }
 233
 234 static UINT STREAMS_get_dimensions(struct tagMSIVIEW *view, UINT *rows, UINT *cols)
 235 {
 236     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 237
 238     TRACE("(%p, %p, %p)\n", view, rows, cols);
 239
 240     if (cols) *cols = sv->num_cols;
 241     if (rows) *rows = sv->db->num_streams;
 242
 243     return ERROR_SUCCESS;
 244 }
 245
 246 static UINT STREAMS_get_column_info( struct tagMSIVIEW *view, UINT n, LPCWSTR *name,
 247                                      UINT *type, BOOL *temporary, LPCWSTR *table_name )
 248 {
 249     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 250
 251     TRACE("(%p, %d, %p, %p, %p, %p)\n", view, n, name, type, temporary, table_name);
 252
 253     if (!n || n > sv->num_cols)
 254         return ERROR_INVALID_PARAMETER;
 255
 256     switch (n)
 257     {
 258     case 1:
 259         if (name) *name = szName;
 260         if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MAX_STREAM_NAME_LEN;
 261         break;
 262
 263     case 2:
 264         if (name) *name = szData;
 265         if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MSITYPE_NULLABLE;
 266         break;
 267     }
 268     if (table_name) *table_name = szStreams;
 269     if (temporary) *temporary = FALSE;
 270     return ERROR_SUCCESS;
 271 }
 272
 273 static UINT streams_modify_update(struct tagMSIVIEW *view, MSIRECORD *rec)
 274 {
 275     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 276     UINT r, row;
 277
 278     r = streams_find_row(sv, rec, &row);
 279     if (r != ERROR_SUCCESS)
 280         return ERROR_FUNCTION_FAILED;
 281
 282     return STREAMS_set_row( view, row, rec, (1 << sv->num_cols) - 1 );
 283 }
 284
 285 static UINT streams_modify_assign(struct tagMSIVIEW *view, MSIRECORD *rec)
 286 {
 287     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 288     UINT r;
 289
 290     r = streams_find_row( sv, rec, NULL );
 291     if (r == ERROR_SUCCESS)
 292         return streams_modify_update(view, rec);
 293
 294     return STREAMS_insert_row(view, rec, -1, FALSE);
 295 }
 296
 297 static UINT STREAMS_modify(struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
 298 {
 299     UINT r;
 300
 301     TRACE("%p %d %p\n", view, eModifyMode, rec);
 302
 303     switch (eModifyMode)
 304     {
 305     case MSIMODIFY_ASSIGN:
 306         r = streams_modify_assign(view, rec);
 307         break;
 308
 309     case MSIMODIFY_INSERT:
 310         r = STREAMS_insert_row(view, rec, -1, FALSE);
 311         break;
 312
 313     case MSIMODIFY_UPDATE:
 314         r = streams_modify_update(view, rec);
 315         break;
 316
 317     case MSIMODIFY_DELETE:
 318         r = STREAMS_delete_row(view, row - 1);
 319         break;
 320
 321     case MSIMODIFY_VALIDATE_NEW:
 322     case MSIMODIFY_INSERT_TEMPORARY:
 323     case MSIMODIFY_REFRESH:
 324     case MSIMODIFY_REPLACE:
 325     case MSIMODIFY_MERGE:
 326     case MSIMODIFY_VALIDATE:
 327     case MSIMODIFY_VALIDATE_FIELD:
 328     case MSIMODIFY_VALIDATE_DELETE:
 329         FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
 330         r = ERROR_CALL_NOT_IMPLEMENTED;
 331         break;
 332
 333     default:
 334         r = ERROR_INVALID_DATA;
 335     }
 336
 337     return r;
 338 }
 339
 340 static UINT STREAMS_delete(struct tagMSIVIEW *view)
 341 {
 342     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 343
 344     TRACE("(%p)\n", view);
 345
 346     msi_free(sv);
 347     return ERROR_SUCCESS;
 348 }
 349
 350 static UINT STREAMS_find_matching_rows(struct tagMSIVIEW *view, UINT col,
 351                                        UINT val, UINT *row, MSIITERHANDLE *handle)
 352 {
 353     MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
 354     UINT index = PtrToUlong(*handle);
 355
 356     TRACE("(%p, %d, %d, %p, %p)\n", view, col, val, row, handle);
 357
 358     if (!col || col > sv->num_cols)
 359         return ERROR_INVALID_PARAMETER;
 360
 361     while (index < sv->db->num_streams)
 362     {
 363         if (sv->db->streams[index].str_index == val)
 364         {
 365             *row = index;
 366             break;
 367         }
 368         index++;
 369     }
 370
 371     *handle = UlongToPtr(++index);
 372
 373     if (index > sv->db->num_streams)
 374         return ERROR_NO_MORE_ITEMS;
 375
 376     return ERROR_SUCCESS;
 377 }
 378
 379 static const MSIVIEWOPS streams_ops =
 380 {
 381     STREAMS_fetch_int,
 382     STREAMS_fetch_stream,
 383     STREAMS_get_row,
 384     STREAMS_set_row,
 385     STREAMS_insert_row,
 386     STREAMS_delete_row,
 387     STREAMS_execute,
 388     STREAMS_close,
 389     STREAMS_get_dimensions,
 390     STREAMS_get_column_info,
 391     STREAMS_modify,
 392     STREAMS_delete,
 393     STREAMS_find_matching_rows,
 394     NULL,
 395     NULL,
 396     NULL,
 397     NULL,
 398     NULL,
 399     NULL,
 400 };
 401
 402 static HRESULT open_stream( MSIDATABASE *db, const WCHAR *name, IStream **stream )
 403 {
 404     HRESULT hr;
 405
 406     hr = IStorage_OpenStream( db->storage, name, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, stream );
 407     if (FAILED( hr ))
 408     {
 409         MSITRANSFORM *transform;
 410
 411         LIST_FOR_EACH_ENTRY( transform, &db->transforms, MSITRANSFORM, entry )
 412         {
 413             hr = IStorage_OpenStream( transform->stg, name, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, stream );
 414             if (SUCCEEDED( hr ))
 415                 break;
 416         }
 417     }
 418     return hr;
 419 }
 420
 421 static MSISTREAM *find_stream( MSIDATABASE *db, const WCHAR *name )
 422 {
 423     UINT r, id, i;
 424
 425     r = msi_string2id( db->strings, name, -1, &id );
 426     if (r != ERROR_SUCCESS)
 427         return NULL;
 428
 429     for (i = 0; i < db->num_streams; i++)
 430     {
 431         if (db->streams[i].str_index == id) return &db->streams[i];
 432     }
 433     return NULL;
 434 }
 435
 436 static UINT append_stream( MSIDATABASE *db, const WCHAR *name, IStream *stream )
 437 {
 438     UINT i = db->num_streams;
 439
 440     if (!streams_resize_table( db, db->num_streams + 1 ))
 441         return ERROR_OUTOFMEMORY;
 442
 443     db->streams[i].str_index = msi_add_string( db->strings, name, -1, StringNonPersistent );
 444     db->streams[i].stream = stream;
 445     db->num_streams++;
 446
 447     TRACE("added %s\n", debugstr_w( name ));
 448     return ERROR_SUCCESS;
 449 }
 450
 451 static UINT load_streams( MSIDATABASE *db )
 452 {
 453     WCHAR decoded[MAX_STREAM_NAME_LEN + 1];
 454     IEnumSTATSTG *stgenum;
 455     STATSTG stat;
 456     HRESULT hr;
 457     UINT count, r = ERROR_SUCCESS;
 458     IStream *stream;
 459
 460     hr = IStorage_EnumElements( db->storage, 0, NULL, 0, &stgenum );
 461     if (FAILED( hr ))
 462         return ERROR_FUNCTION_FAILED;
 463
 464     for (;;)
 465     {
 466         count = 0;
 467         hr = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
 468         if (FAILED( hr ) || !count)
 469             break;
 470
 471         /* table streams are not in the _Streams table */
 472         if (stat.type != STGTY_STREAM || *stat.pwcsName == 0x4840)
 473         {
 474             CoTaskMemFree( stat.pwcsName );
 475             continue;
 476         }
 477         decode_streamname( stat.pwcsName, decoded );
 478         if (find_stream( db, decoded ))
 479         {
 480             CoTaskMemFree( stat.pwcsName );
 481             continue;
 482         }
 483         TRACE("found new stream %s\n", debugstr_w( decoded ));
 484
 485         hr = open_stream( db, stat.pwcsName, &stream );
 486         CoTaskMemFree( stat.pwcsName );
 487         if (FAILED( hr ))
 488         {
 489             ERR("unable to open stream %08x\n", hr);
 490             r = ERROR_FUNCTION_FAILED;
 491             break;
 492         }
 493
 494         r = append_stream( db, decoded, stream );
 495         if (r != ERROR_SUCCESS)
 496             break;
 497     }
 498
 499     TRACE("loaded %u streams\n", db->num_streams);
 500     IEnumSTATSTG_Release( stgenum );
 501     return r;
 502 }
 503
 504 UINT msi_get_stream( MSIDATABASE *db, const WCHAR *name, IStream **ret )
 505 {
 506     MSISTREAM *stream;
 507     WCHAR *encname;
 508     HRESULT hr;
 509     UINT r;
 510
 511     if ((stream = find_stream( db, name )))
 512     {
 513         LARGE_INTEGER pos;
 514
 515         pos.QuadPart = 0;
 516         hr = IStream_Seek( stream->stream, pos, STREAM_SEEK_SET, NULL );
 517         if (FAILED( hr ))
 518             return ERROR_FUNCTION_FAILED;
 519
 520         *ret = stream->stream;
 521         IStream_AddRef( *ret );
 522         return ERROR_SUCCESS;
 523     }
 524
 525     if (!(encname = encode_streamname( FALSE, name )))
 526         return ERROR_OUTOFMEMORY;
 527
 528     hr = open_stream( db, encname, ret );
 529     msi_free( encname );
 530     if (FAILED( hr ))
 531         return ERROR_FUNCTION_FAILED;
 532
 533     r = append_stream( db, name, *ret );
 534     if (r != ERROR_SUCCESS)
 535     {
 536         IStream_Release( *ret );
 537         return r;
 538     }
 539
 540     IStream_AddRef( *ret );
 541     return ERROR_SUCCESS;
 542 }
 543
 544 UINT STREAMS_CreateView(MSIDATABASE *db, MSIVIEW **view)
 545 {
 546     MSISTREAMSVIEW *sv;
 547     UINT r;
 548
 549     TRACE("(%p, %p)\n", db, view);
 550
 551     r = load_streams( db );
 552     if (r != ERROR_SUCCESS)
 553         return r;
 554
 555     if (!(sv = msi_alloc_zero( sizeof(MSISTREAMSVIEW) )))
 556         return ERROR_OUTOFMEMORY;
 557
 558     sv->view.ops = &streams_ops;
 559     sv->num_cols = NUM_STREAMS_COLS;
 560     sv->db = db;
 561
 562     *view = (MSIVIEW *)sv;
 563
 564     return ERROR_SUCCESS;
 565 }
 566
 567 static HRESULT write_stream( IStream *dst, IStream *src )
 568 {
 569     HRESULT hr;
 570     char buf[4096];
 571     STATSTG stat;
 572     LARGE_INTEGER pos;
 573     UINT count, size;
 574
 575     hr = IStream_Stat( src, &stat, STATFLAG_NONAME );
 576     if (FAILED( hr )) return hr;
 577
 578     hr = IStream_SetSize( dst, stat.cbSize );
 579     if (FAILED( hr )) return hr;
 580
 581     pos.QuadPart = 0;
 582     hr = IStream_Seek( dst, pos, STREAM_SEEK_SET, NULL );
 583     if (FAILED( hr )) return hr;
 584
 585     for (;;)
 586     {
 587         size = min( sizeof(buf), stat.cbSize.QuadPart );
 588         hr = IStream_Read( src, buf, size, &count );
 589         if (FAILED( hr ) || count != size)
 590         {
 591             WARN("failed to read stream: %08x\n", hr);
 592             return E_INVALIDARG;
 593         }
 594         stat.cbSize.QuadPart -= count;
 595         if (count)
 596         {
 597             size = count;
 598             hr = IStream_Write( dst, buf, size, &count );
 599             if (FAILED( hr ) || count != size)
 600             {
 601                 WARN("failed to write stream: %08x\n", hr);
 602                 return E_INVALIDARG;
 603             }
 604         }
 605         if (!stat.cbSize.QuadPart) break;
 606     }
 607
 608     return S_OK;
 609 }
 610
 611 UINT msi_commit_streams( MSIDATABASE *db )
 612 {
 613     UINT i;
 614     const WCHAR *name;
 615     WCHAR *encname;
 616     IStream *stream;
 617     HRESULT hr;
 618
 619     TRACE("got %u streams\n", db->num_streams);
 620
 621     for (i = 0; i < db->num_streams; i++)
 622     {
 623         name = msi_string_lookup( db->strings, db->streams[i].str_index, NULL );
 624         if (!(encname = encode_streamname( FALSE, name ))) return ERROR_OUTOFMEMORY;
 625
 626         hr = IStorage_CreateStream( db->storage, encname, STGM_WRITE|STGM_SHARE_EXCLUSIVE, 0, 0, &stream );
 627         if (SUCCEEDED( hr ))
 628         {
 629             hr = write_stream( stream, db->streams[i].stream );
 630             if (FAILED( hr ))
 631             {
 632                 ERR("failed to write stream %s (hr = %08x)\n", debugstr_w(encname), hr);
 633                 msi_free( encname );
 634                 IStream_Release( stream );
 635                 return ERROR_FUNCTION_FAILED;
 636             }
 637             hr = IStream_Commit( stream, 0 );
 638             IStream_Release( stream );
 639             if (FAILED( hr ))
 640             {
 641                 ERR("failed to commit stream %s (hr = %08x)\n", debugstr_w(encname), hr);
 642                 msi_free( encname );
 643                 return ERROR_FUNCTION_FAILED;
 644             }
 645         }
 646         else if (hr != STG_E_FILEALREADYEXISTS)
 647         {
 648             ERR("failed to create stream %s (hr = %08x)\n", debugstr_w(encname), hr);
 649             msi_free( encname );
 650             return ERROR_FUNCTION_FAILED;
 651         }
 652         msi_free( encname );
 653     }
 654
 655     return ERROR_SUCCESS;
 656 }