| /* | |
| * Implementation of the Microsoft Installer (msi.dll) | |
| * | |
| * Copyright 2007 James Hawkins | |
| * Copyright 2015 Hans Leidekker for CodeWeavers | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #include <stdarg.h> | |
| #define COBJMACROS | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "winerror.h" | |
| #include "msi.h" | |
| #include "msiquery.h" | |
| #include "objbase.h" | |
| #include "msipriv.h" | |
| #include "query.h" | |
| #include "wine/debug.h" | |
| #include "wine/unicode.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(msidb); | |
| #define NUM_STREAMS_COLS 2 | |
| typedef struct tagMSISTREAMSVIEW | |
| { | |
| MSIVIEW view; | |
| MSIDATABASE *db; | |
| UINT num_cols; | |
| } MSISTREAMSVIEW; | |
| static BOOL streams_resize_table( MSIDATABASE *db, UINT size ) | |
| { | |
| if (!db->num_streams_allocated) | |
| { | |
| if (!(db->streams = msi_alloc_zero( size * sizeof(MSISTREAM) ))) return FALSE; | |
| db->num_streams_allocated = size; | |
| return TRUE; | |
| } | |
| while (size >= db->num_streams_allocated) | |
| { | |
| MSISTREAM *tmp; | |
| UINT new_size = db->num_streams_allocated * 2; | |
| if (!(tmp = msi_realloc_zero( db->streams, new_size * sizeof(MSISTREAM) ))) return FALSE; | |
| db->streams = tmp; | |
| db->num_streams_allocated = new_size; | |
| } | |
| return TRUE; | |
| } | |
| static UINT STREAMS_fetch_int(struct tagMSIVIEW *view, UINT row, UINT col, UINT *val) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| TRACE("(%p, %d, %d, %p)\n", view, row, col, val); | |
| if (col != 1) | |
| return ERROR_INVALID_PARAMETER; | |
| if (row >= sv->db->num_streams) | |
| return ERROR_NO_MORE_ITEMS; | |
| *val = sv->db->streams[row].str_index; | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT STREAMS_fetch_stream(struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| LARGE_INTEGER pos; | |
| HRESULT hr; | |
| TRACE("(%p, %d, %d, %p)\n", view, row, col, stm); | |
| if (row >= sv->db->num_streams) | |
| return ERROR_FUNCTION_FAILED; | |
| pos.QuadPart = 0; | |
| hr = IStream_Seek( sv->db->streams[row].stream, pos, STREAM_SEEK_SET, NULL ); | |
| if (FAILED( hr )) | |
| return ERROR_FUNCTION_FAILED; | |
| *stm = sv->db->streams[row].stream; | |
| IStream_AddRef( *stm ); | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT STREAMS_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec ) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| TRACE("%p %d %p\n", sv, row, rec); | |
| return msi_view_get_row( sv->db, view, row, rec ); | |
| } | |
| static UINT STREAMS_set_row(struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| TRACE("(%p, %d, %p, %08x)\n", view, row, rec, mask); | |
| if (row > sv->db->num_streams || mask >= (1 << sv->num_cols)) | |
| return ERROR_INVALID_PARAMETER; | |
| if (mask & 1) | |
| { | |
| const WCHAR *name = MSI_RecordGetString( rec, 1 ); | |
| if (!name) return ERROR_INVALID_PARAMETER; | |
| sv->db->streams[row].str_index = msi_add_string( sv->db->strings, name, -1, StringNonPersistent ); | |
| } | |
| if (mask & 2) | |
| { | |
| IStream *old, *new; | |
| HRESULT hr; | |
| UINT r; | |
| r = MSI_RecordGetIStream( rec, 2, &new ); | |
| if (r != ERROR_SUCCESS) | |
| return r; | |
| old = sv->db->streams[row].stream; | |
| hr = IStream_QueryInterface( new, &IID_IStream, (void **)&sv->db->streams[row].stream ); | |
| if (FAILED( hr )) | |
| { | |
| IStream_Release( new ); | |
| return ERROR_FUNCTION_FAILED; | |
| } | |
| if (old) IStream_Release( old ); | |
| } | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT streams_find_row( MSISTREAMSVIEW *sv, MSIRECORD *rec, UINT *row ) | |
| { | |
| const WCHAR *str; | |
| UINT r, i, id, val; | |
| str = MSI_RecordGetString( rec, 1 ); | |
| r = msi_string2id( sv->db->strings, str, -1, &id ); | |
| if (r != ERROR_SUCCESS) | |
| return r; | |
| for (i = 0; i < sv->db->num_streams; i++) | |
| { | |
| STREAMS_fetch_int( &sv->view, i, 1, &val ); | |
| if (val == id) | |
| { | |
| if (row) *row = i; | |
| return ERROR_SUCCESS; | |
| } | |
| } | |
| return ERROR_FUNCTION_FAILED; | |
| } | |
| static UINT STREAMS_insert_row(struct tagMSIVIEW *view, MSIRECORD *rec, UINT row, BOOL temporary) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| UINT i, r, num_rows = sv->db->num_streams + 1; | |
| TRACE("(%p, %p, %d, %d)\n", view, rec, row, temporary); | |
| r = streams_find_row( sv, rec, NULL ); | |
| if (r == ERROR_SUCCESS) | |
| return ERROR_FUNCTION_FAILED; | |
| if (!streams_resize_table( sv->db, num_rows )) | |
| return ERROR_FUNCTION_FAILED; | |
| if (row == -1) | |
| row = num_rows - 1; | |
| /* shift the rows to make room for the new row */ | |
| for (i = num_rows - 1; i > row; i--) | |
| { | |
| sv->db->streams[i] = sv->db->streams[i - 1]; | |
| } | |
| r = STREAMS_set_row( view, row, rec, (1 << sv->num_cols) - 1 ); | |
| if (r == ERROR_SUCCESS) | |
| sv->db->num_streams = num_rows; | |
| return r; | |
| } | |
| static UINT STREAMS_delete_row(struct tagMSIVIEW *view, UINT row) | |
| { | |
| FIXME("(%p %d): stub!\n", view, row); | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT STREAMS_execute(struct tagMSIVIEW *view, MSIRECORD *record) | |
| { | |
| TRACE("(%p, %p)\n", view, record); | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT STREAMS_close(struct tagMSIVIEW *view) | |
| { | |
| TRACE("(%p)\n", view); | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT STREAMS_get_dimensions(struct tagMSIVIEW *view, UINT *rows, UINT *cols) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| TRACE("(%p, %p, %p)\n", view, rows, cols); | |
| if (cols) *cols = sv->num_cols; | |
| if (rows) *rows = sv->db->num_streams; | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT STREAMS_get_column_info( struct tagMSIVIEW *view, UINT n, LPCWSTR *name, | |
| UINT *type, BOOL *temporary, LPCWSTR *table_name ) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| TRACE("(%p, %d, %p, %p, %p, %p)\n", view, n, name, type, temporary, table_name); | |
| if (!n || n > sv->num_cols) | |
| return ERROR_INVALID_PARAMETER; | |
| switch (n) | |
| { | |
| case 1: | |
| if (name) *name = szName; | |
| if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MAX_STREAM_NAME_LEN; | |
| break; | |
| case 2: | |
| if (name) *name = szData; | |
| if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MSITYPE_NULLABLE; | |
| break; | |
| } | |
| if (table_name) *table_name = szStreams; | |
| if (temporary) *temporary = FALSE; | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT streams_modify_update(struct tagMSIVIEW *view, MSIRECORD *rec) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| UINT r, row; | |
| r = streams_find_row(sv, rec, &row); | |
| if (r != ERROR_SUCCESS) | |
| return ERROR_FUNCTION_FAILED; | |
| return STREAMS_set_row( view, row, rec, (1 << sv->num_cols) - 1 ); | |
| } | |
| static UINT streams_modify_assign(struct tagMSIVIEW *view, MSIRECORD *rec) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| UINT r; | |
| r = streams_find_row( sv, rec, NULL ); | |
| if (r == ERROR_SUCCESS) | |
| return streams_modify_update(view, rec); | |
| return STREAMS_insert_row(view, rec, -1, FALSE); | |
| } | |
| static UINT STREAMS_modify(struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row) | |
| { | |
| UINT r; | |
| TRACE("%p %d %p\n", view, eModifyMode, rec); | |
| switch (eModifyMode) | |
| { | |
| case MSIMODIFY_ASSIGN: | |
| r = streams_modify_assign(view, rec); | |
| break; | |
| case MSIMODIFY_INSERT: | |
| r = STREAMS_insert_row(view, rec, -1, FALSE); | |
| break; | |
| case MSIMODIFY_UPDATE: | |
| r = streams_modify_update(view, rec); | |
| break; | |
| case MSIMODIFY_VALIDATE_NEW: | |
| case MSIMODIFY_INSERT_TEMPORARY: | |
| case MSIMODIFY_REFRESH: | |
| case MSIMODIFY_REPLACE: | |
| case MSIMODIFY_MERGE: | |
| case MSIMODIFY_DELETE: | |
| case MSIMODIFY_VALIDATE: | |
| case MSIMODIFY_VALIDATE_FIELD: | |
| case MSIMODIFY_VALIDATE_DELETE: | |
| FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec ); | |
| r = ERROR_CALL_NOT_IMPLEMENTED; | |
| break; | |
| default: | |
| r = ERROR_INVALID_DATA; | |
| } | |
| return r; | |
| } | |
| static UINT STREAMS_delete(struct tagMSIVIEW *view) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| TRACE("(%p)\n", view); | |
| msi_free(sv); | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT STREAMS_find_matching_rows(struct tagMSIVIEW *view, UINT col, | |
| UINT val, UINT *row, MSIITERHANDLE *handle) | |
| { | |
| MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view; | |
| UINT index = PtrToUlong(*handle); | |
| TRACE("(%p, %d, %d, %p, %p)\n", view, col, val, row, handle); | |
| if (!col || col > sv->num_cols) | |
| return ERROR_INVALID_PARAMETER; | |
| while (index < sv->db->num_streams) | |
| { | |
| if (sv->db->streams[index].str_index == val) | |
| { | |
| *row = index; | |
| break; | |
| } | |
| index++; | |
| } | |
| *handle = UlongToPtr(++index); | |
| if (index > sv->db->num_streams) | |
| return ERROR_NO_MORE_ITEMS; | |
| return ERROR_SUCCESS; | |
| } | |
| static const MSIVIEWOPS streams_ops = | |
| { | |
| STREAMS_fetch_int, | |
| STREAMS_fetch_stream, | |
| STREAMS_get_row, | |
| STREAMS_set_row, | |
| STREAMS_insert_row, | |
| STREAMS_delete_row, | |
| STREAMS_execute, | |
| STREAMS_close, | |
| STREAMS_get_dimensions, | |
| STREAMS_get_column_info, | |
| STREAMS_modify, | |
| STREAMS_delete, | |
| STREAMS_find_matching_rows, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| }; | |
| static HRESULT open_stream( MSIDATABASE *db, const WCHAR *name, IStream **stream ) | |
| { | |
| HRESULT hr; | |
| hr = IStorage_OpenStream( db->storage, name, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, stream ); | |
| if (FAILED( hr )) | |
| { | |
| MSITRANSFORM *transform; | |
| LIST_FOR_EACH_ENTRY( transform, &db->transforms, MSITRANSFORM, entry ) | |
| { | |
| hr = IStorage_OpenStream( transform->stg, name, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, stream ); | |
| if (SUCCEEDED( hr )) | |
| break; | |
| } | |
| } | |
| return hr; | |
| } | |
| static MSISTREAM *find_stream( MSIDATABASE *db, const WCHAR *name ) | |
| { | |
| UINT r, id, i; | |
| r = msi_string2id( db->strings, name, -1, &id ); | |
| if (r != ERROR_SUCCESS) | |
| return NULL; | |
| for (i = 0; i < db->num_streams; i++) | |
| { | |
| if (db->streams[i].str_index == id) return &db->streams[i]; | |
| } | |
| return NULL; | |
| } | |
| static UINT append_stream( MSIDATABASE *db, const WCHAR *name, IStream *stream ) | |
| { | |
| UINT i = db->num_streams; | |
| if (!streams_resize_table( db, db->num_streams + 1 )) | |
| return ERROR_OUTOFMEMORY; | |
| db->streams[i].str_index = msi_add_string( db->strings, name, -1, StringNonPersistent ); | |
| db->streams[i].stream = stream; | |
| db->num_streams++; | |
| TRACE("added %s\n", debugstr_w( name )); | |
| return ERROR_SUCCESS; | |
| } | |
| static UINT load_streams( MSIDATABASE *db ) | |
| { | |
| WCHAR decoded[MAX_STREAM_NAME_LEN + 1]; | |
| IEnumSTATSTG *stgenum; | |
| STATSTG stat; | |
| HRESULT hr; | |
| UINT count, r = ERROR_SUCCESS; | |
| IStream *stream; | |
| hr = IStorage_EnumElements( db->storage, 0, NULL, 0, &stgenum ); | |
| if (FAILED( hr )) | |
| return ERROR_FUNCTION_FAILED; | |
| for (;;) | |
| { | |
| count = 0; | |
| hr = IEnumSTATSTG_Next( stgenum, 1, &stat, &count ); | |
| if (FAILED( hr ) || !count) | |
| break; | |
| /* table streams are not in the _Streams table */ | |
| if (stat.type != STGTY_STREAM || *stat.pwcsName == 0x4840) | |
| { | |
| CoTaskMemFree( stat.pwcsName ); | |
| continue; | |
| } | |
| decode_streamname( stat.pwcsName, decoded ); | |
| if (find_stream( db, decoded )) | |
| { | |
| CoTaskMemFree( stat.pwcsName ); | |
| continue; | |
| } | |
| TRACE("found new stream %s\n", debugstr_w( decoded )); | |
| hr = open_stream( db, stat.pwcsName, &stream ); | |
| CoTaskMemFree( stat.pwcsName ); | |
| if (FAILED( hr )) | |
| { | |
| ERR("unable to open stream %08x\n", hr); | |
| r = ERROR_FUNCTION_FAILED; | |
| break; | |
| } | |
| r = append_stream( db, decoded, stream ); | |
| if (r != ERROR_SUCCESS) | |
| break; | |
| } | |
| TRACE("loaded %u streams\n", db->num_streams); | |
| IEnumSTATSTG_Release( stgenum ); | |
| return r; | |
| } | |
| UINT msi_get_stream( MSIDATABASE *db, const WCHAR *name, IStream **ret ) | |
| { | |
| MSISTREAM *stream; | |
| WCHAR *encname; | |
| HRESULT hr; | |
| UINT r; | |
| if ((stream = find_stream( db, name ))) | |
| { | |
| LARGE_INTEGER pos; | |
| pos.QuadPart = 0; | |
| hr = IStream_Seek( stream->stream, pos, STREAM_SEEK_SET, NULL ); | |
| if (FAILED( hr )) | |
| return ERROR_FUNCTION_FAILED; | |
| *ret = stream->stream; | |
| IStream_AddRef( *ret ); | |
| return ERROR_SUCCESS; | |
| } | |
| if (!(encname = encode_streamname( FALSE, name ))) | |
| return ERROR_OUTOFMEMORY; | |
| hr = open_stream( db, encname, ret ); | |
| msi_free( encname ); | |
| if (FAILED( hr )) | |
| return ERROR_FUNCTION_FAILED; | |
| r = append_stream( db, name, *ret ); | |
| if (r != ERROR_SUCCESS) | |
| { | |
| IStream_Release( *ret ); | |
| return r; | |
| } | |
| IStream_AddRef( *ret ); | |
| return ERROR_SUCCESS; | |
| } | |
| UINT STREAMS_CreateView(MSIDATABASE *db, MSIVIEW **view) | |
| { | |
| MSISTREAMSVIEW *sv; | |
| UINT r; | |
| TRACE("(%p, %p)\n", db, view); | |
| r = load_streams( db ); | |
| if (r != ERROR_SUCCESS) | |
| return r; | |
| if (!(sv = msi_alloc_zero( sizeof(MSISTREAMSVIEW) ))) | |
| return ERROR_OUTOFMEMORY; | |
| sv->view.ops = &streams_ops; | |
| sv->num_cols = NUM_STREAMS_COLS; | |
| sv->db = db; | |
| *view = (MSIVIEW *)sv; | |
| return ERROR_SUCCESS; | |
| } | |
| static HRESULT write_stream( IStream *dst, IStream *src ) | |
| { | |
| HRESULT hr; | |
| char buf[4096]; | |
| STATSTG stat; | |
| LARGE_INTEGER pos; | |
| UINT count, size; | |
| hr = IStream_Stat( src, &stat, STATFLAG_NONAME ); | |
| if (FAILED( hr )) return hr; | |
| hr = IStream_SetSize( dst, stat.cbSize ); | |
| if (FAILED( hr )) return hr; | |
| pos.QuadPart = 0; | |
| hr = IStream_Seek( dst, pos, STREAM_SEEK_SET, NULL ); | |
| if (FAILED( hr )) return hr; | |
| for (;;) | |
| { | |
| size = min( sizeof(buf), stat.cbSize.QuadPart ); | |
| hr = IStream_Read( src, buf, size, &count ); | |
| if (FAILED( hr ) || count != size) | |
| { | |
| WARN("failed to read stream: %08x\n", hr); | |
| return E_INVALIDARG; | |
| } | |
| stat.cbSize.QuadPart -= count; | |
| if (count) | |
| { | |
| size = count; | |
| hr = IStream_Write( dst, buf, size, &count ); | |
| if (FAILED( hr ) || count != size) | |
| { | |
| WARN("failed to write stream: %08x\n", hr); | |
| return E_INVALIDARG; | |
| } | |
| } | |
| if (!stat.cbSize.QuadPart) break; | |
| } | |
| return S_OK; | |
| } | |
| UINT msi_commit_streams( MSIDATABASE *db ) | |
| { | |
| UINT i; | |
| const WCHAR *name; | |
| WCHAR *encname; | |
| IStream *stream; | |
| HRESULT hr; | |
| TRACE("got %u streams\n", db->num_streams); | |
| for (i = 0; i < db->num_streams; i++) | |
| { | |
| name = msi_string_lookup( db->strings, db->streams[i].str_index, NULL ); | |
| if (!(encname = encode_streamname( FALSE, name ))) return ERROR_OUTOFMEMORY; | |
| hr = IStorage_CreateStream( db->storage, encname, STGM_WRITE|STGM_SHARE_EXCLUSIVE, 0, 0, &stream ); | |
| if (SUCCEEDED( hr )) | |
| { | |
| hr = write_stream( stream, db->streams[i].stream ); | |
| if (FAILED( hr )) | |
| { | |
| ERR("failed to write stream %s (hr = %08x)\n", debugstr_w(encname), hr); | |
| msi_free( encname ); | |
| IStream_Release( stream ); | |
| return ERROR_FUNCTION_FAILED; | |
| } | |
| hr = IStream_Commit( stream, 0 ); | |
| IStream_Release( stream ); | |
| if (FAILED( hr )) | |
| { | |
| ERR("failed to commit stream %s (hr = %08x)\n", debugstr_w(encname), hr); | |
| msi_free( encname ); | |
| return ERROR_FUNCTION_FAILED; | |
| } | |
| } | |
| else if (hr != STG_E_FILEALREADYEXISTS) | |
| { | |
| ERR("failed to create stream %s (hr = %08x)\n", debugstr_w(encname), hr); | |
| msi_free( encname ); | |
| return ERROR_FUNCTION_FAILED; | |
| } | |
| msi_free( encname ); | |
| } | |
| return ERROR_SUCCESS; | |
| } |