diff --git a/dlls/msi/Makefile.in b/dlls/msi/Makefile.in index bcaa7e9..b6dfc13 100644 --- a/dlls/msi/Makefile.in +++ b/dlls/msi/Makefile.in @@ -39,6 +39,7 @@ C_SRCS = \ script.c \ select.c \ source.c \ + storages.c \ streams.c \ string.c \ suminfo.c \ diff --git a/dlls/msi/msiquery.c b/dlls/msi/msiquery.c index 912a299..4435cd9 100644 --- a/dlls/msi/msiquery.c +++ b/dlls/msi/msiquery.c @@ -326,7 +326,7 @@ UINT msi_view_get_row(MSIDATABASE *db, MSIVIEW *view, UINT row, MSIRECORD **rec) IStream_Release(stm); } else - ERR("failed to get stream\n"); + WARN("failed to get stream\n"); continue; } diff --git a/dlls/msi/query.h b/dlls/msi/query.h index 73ed502..53dcf63 100644 --- a/dlls/msi/query.h +++ b/dlls/msi/query.h @@ -115,6 +115,8 @@ UINT ALTER_CreateView( MSIDATABASE *db, MSIVIEW **view, LPCWSTR name, column_inf UINT STREAMS_CreateView( MSIDATABASE *db, MSIVIEW **view ); +UINT STORAGES_CreateView( MSIDATABASE *db, MSIVIEW **view ); + int sqliteGetToken(const WCHAR *z, int *tokenType); MSIRECORD *msi_query_merge_record( UINT fields, const column_info *vl, MSIRECORD *rec ); diff --git a/dlls/msi/storages.c b/dlls/msi/storages.c new file mode 100644 index 0000000..7b20dd9 --- /dev/null +++ b/dlls/msi/storages.c @@ -0,0 +1,560 @@ +/* + * Implementation of the Microsoft Installer (msi.dll) + * + * Copyright 2008 James Hawkins + * + * 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 + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "winerror.h" +#include "ole2.h" +#include "msi.h" +#include "msiquery.h" +#include "objbase.h" +#include "msipriv.h" +#include "query.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(msidb); + +#define NUM_STORAGES_COLS 2 +#define MAX_STORAGES_NAME_LEN 62 + +typedef struct tabSTORAGE +{ + UINT str_index; + LPWSTR name; + IStorage *storage; +} STORAGE; + +typedef struct tagMSISTORAGESVIEW +{ + MSIVIEW view; + MSIDATABASE *db; + STORAGE **storages; + UINT max_storages; + UINT num_rows; + UINT row_size; +} MSISTORAGESVIEW; + +static BOOL storages_set_table_size(MSISTORAGESVIEW *sv, UINT size) +{ + if (size >= sv->max_storages) + { + sv->max_storages *= 2; + sv->storages = msi_realloc(sv->storages, sv->max_storages * sizeof(STORAGE *)); + if (!sv->storages) + return FALSE; + } + + return TRUE; +} + +static STORAGE *create_storage(MSISTORAGESVIEW *sv, LPWSTR name, IStorage *stg) +{ + STORAGE *storage; + + storage = msi_alloc(sizeof(STORAGE)); + if (!storage) + return NULL; + + storage->name = strdupW(name); + if (!storage->name) + { + msi_free(storage); + return NULL; + } + + storage->str_index = msi_addstringW(sv->db->strings, 0, storage->name, -1, 1, StringNonPersistent); + storage->storage = stg; + + if (storage->storage) + IStorage_AddRef(storage->storage); + + return storage; +} + +static UINT STORAGES_fetch_int(struct tagMSIVIEW *view, UINT row, UINT col, UINT *val) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + + TRACE("(%p, %d, %d, %p)\n", view, row, col, val); + + if (col != 1) + return ERROR_INVALID_PARAMETER; + + if (row >= sv->num_rows) + return ERROR_NO_MORE_ITEMS; + + *val = sv->storages[row]->str_index; + + return ERROR_SUCCESS; +} + +static UINT STORAGES_fetch_stream(struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + + TRACE("(%p, %d, %d, %p)\n", view, row, col, stm); + + if (row >= sv->num_rows) + return ERROR_FUNCTION_FAILED; + + return ERROR_INVALID_DATA; +} + +static UINT STORAGES_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec ) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + + FIXME("%p %d %p\n", sv, row, rec); + + return ERROR_CALL_NOT_IMPLEMENTED; +} + +static HRESULT stream_to_storage(IStream *stm, IStorage **stg) +{ + ILockBytes *lockbytes; + STATSTG stat; + LPVOID data; + HRESULT hr; + DWORD size, read; + ULARGE_INTEGER offset; + + hr = IStream_Stat(stm, &stat, STATFLAG_NONAME); + if (FAILED(hr)) + return hr; + + if (stat.cbSize.QuadPart >> 32) + { + ERR("Storage is too large\n"); + return E_FAIL; + } + + size = stat.cbSize.QuadPart; + data = msi_alloc(size); + if (!data) + return E_OUTOFMEMORY; + + hr = IStream_Read(stm, data, size, &read); + if (FAILED(hr) || read != size) + goto done; + + hr = CreateILockBytesOnHGlobal(NULL, TRUE, &lockbytes); + if (FAILED(hr)) + goto done; + + ZeroMemory(&offset, sizeof(ULARGE_INTEGER)); + hr = ILockBytes_WriteAt(lockbytes, offset, data, size, &read); + if (FAILED(hr) || read != size) + goto done; + + hr = StgOpenStorageOnILockBytes(lockbytes, NULL, + STGM_READWRITE | STGM_SHARE_DENY_NONE, + NULL, 0, stg); + if (FAILED(hr)) + goto done; + +done: + msi_free(data); + ILockBytes_Release(lockbytes); + return hr; +} + +static UINT STORAGES_set_row(struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + IStorage *stg, *substg; + IStream *stm; + LPWSTR name = NULL; + HRESULT hr; + UINT r = ERROR_FUNCTION_FAILED; + + TRACE("(%p, %p)\n", view, rec); + + if (row > sv->num_rows) + return ERROR_FUNCTION_FAILED; + + r = MSI_RecordGetIStream(rec, 2, &stm); + if (r != ERROR_SUCCESS) + return r; + + r = stream_to_storage(stm, &stg); + if (r != ERROR_SUCCESS) + { + IStream_Release(stm); + return r; + } + + name = strdupW(MSI_RecordGetString(rec, 1)); + if (!name) + { + r = ERROR_OUTOFMEMORY; + goto done; + } + + hr = IStorage_CreateStorage(sv->db->storage, name, + STGM_WRITE | STGM_SHARE_EXCLUSIVE, + 0, 0, &substg); + if (FAILED(hr)) + { + r = ERROR_FUNCTION_FAILED; + goto done; + } + + hr = IStorage_CopyTo(stg, 0, NULL, NULL, substg); + if (FAILED(hr)) + { + r = ERROR_FUNCTION_FAILED; + goto done; + } + + sv->storages[row] = create_storage(sv, name, stg); + if (!sv->storages[row]) + r = ERROR_FUNCTION_FAILED; + +done: + msi_free(name); + + IStorage_Release(substg); + IStorage_Release(stg); + IStream_Release(stm); + + return r; +} + +static UINT STORAGES_insert_row(struct tagMSIVIEW *view, MSIRECORD *rec, BOOL temporary) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + + if (!storages_set_table_size(sv, ++sv->num_rows)) + return ERROR_FUNCTION_FAILED; + + return STORAGES_set_row(view, sv->num_rows - 1, rec, 0); +} + +static UINT STORAGES_delete_row(struct tagMSIVIEW *view, UINT row) +{ + FIXME("(%p %d): stub!\n", view, row); + return ERROR_SUCCESS; +} + +static UINT STORAGES_execute(struct tagMSIVIEW *view, MSIRECORD *record) +{ + TRACE("(%p, %p)\n", view, record); + return ERROR_SUCCESS; +} + +static UINT STORAGES_close(struct tagMSIVIEW *view) +{ + TRACE("(%p)\n", view); + return ERROR_SUCCESS; +} + +static UINT STORAGES_get_dimensions(struct tagMSIVIEW *view, UINT *rows, UINT *cols) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + + TRACE("(%p, %p, %p)\n", view, rows, cols); + + if (cols) *cols = NUM_STORAGES_COLS; + if (rows) *rows = sv->num_rows; + + return ERROR_SUCCESS; +} + +static UINT STORAGES_get_column_info(struct tagMSIVIEW *view, + UINT n, LPWSTR *name, UINT *type) +{ + LPCWSTR name_ptr = NULL; + + static const WCHAR Name[] = {'N','a','m','e',0}; + static const WCHAR Data[] = {'D','a','t','a',0}; + + TRACE("(%p, %d, %p, %p)\n", view, n, name, type); + + if (n == 0 || n > NUM_STORAGES_COLS) + return ERROR_INVALID_PARAMETER; + + switch (n) + { + case 1: + name_ptr = Name; + if (type) *type = MSITYPE_STRING | MAX_STORAGES_NAME_LEN; + break; + + case 2: + name_ptr = Data; + if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MSITYPE_NULLABLE; + break; + } + + if (name) + { + *name = strdupW(name_ptr); + if (!*name) return ERROR_FUNCTION_FAILED; + } + + return ERROR_SUCCESS; +} + +static UINT storages_find_row(MSISTORAGESVIEW *sv, MSIRECORD *rec, UINT *row) +{ + LPCWSTR str; + UINT i, id, data; + + str = MSI_RecordGetString(rec, 1); + msi_string2idW(sv->db->strings, str, &id); + + for (i = 0; i < sv->num_rows; i++) + { + STORAGES_fetch_int(&sv->view, i, 1, &data); + + if (data == id) + { + *row = i; + return ERROR_SUCCESS; + } + } + + return ERROR_FUNCTION_FAILED; +} + +static UINT storages_modify_update(struct tagMSIVIEW *view, MSIRECORD *rec) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + UINT r, row; + + r = storages_find_row(sv, rec, &row); + if (r != ERROR_SUCCESS) + return ERROR_FUNCTION_FAILED; + + return STORAGES_set_row(view, row, rec, 0); +} + +static UINT storages_modify_assign(struct tagMSIVIEW *view, MSIRECORD *rec) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + UINT r, row; + + r = storages_find_row(sv, rec, &row); + if (r == ERROR_SUCCESS) + return storages_modify_update(view, rec); + + return STORAGES_insert_row(view, rec, FALSE); +} + +static UINT STORAGES_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 = storages_modify_assign(view, rec); + break; + + case MSIMODIFY_INSERT: + r = STORAGES_insert_row(view, rec, FALSE); + break; + + case MSIMODIFY_UPDATE: + r = storages_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 STORAGES_delete(struct tagMSIVIEW *view) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + UINT i; + + TRACE("(%p)\n", view); + + for (i = 0; i < sv->num_rows; i++) + { + if (sv->storages[i]->storage) + IStorage_Release(sv->storages[i]->storage); + + msi_free(sv->storages[i]); + } + + msi_free(sv->storages); + sv->storages = NULL; + + return ERROR_SUCCESS; +} + +static UINT STORAGES_find_matching_rows(struct tagMSIVIEW *view, UINT col, + UINT val, UINT *row, MSIITERHANDLE *handle) +{ + MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view; + UINT index = (UINT)*handle; + + TRACE("(%d, %d): %d\n", *row, col, val); + + if (col == 0 || col > NUM_STORAGES_COLS) + return ERROR_INVALID_PARAMETER; + + while (index < sv->num_rows) + { + if (sv->storages[index]->str_index == val) + { + *row = index; + break; + } + + index++; + } + + *handle = (MSIITERHANDLE)++index; + if (index >= sv->num_rows) + return ERROR_NO_MORE_ITEMS; + + return ERROR_SUCCESS; +} + +static const MSIVIEWOPS storages_ops = +{ + STORAGES_fetch_int, + STORAGES_fetch_stream, + STORAGES_get_row, + STORAGES_set_row, + STORAGES_insert_row, + STORAGES_delete_row, + STORAGES_execute, + STORAGES_close, + STORAGES_get_dimensions, + STORAGES_get_column_info, + STORAGES_modify, + STORAGES_delete, + STORAGES_find_matching_rows, + NULL, + NULL, + NULL, + NULL, + NULL, +}; + +static INT add_storages_to_table(MSISTORAGESVIEW *sv) +{ + STORAGE *storage = NULL; + IEnumSTATSTG *stgenum = NULL; + STATSTG stat; + HRESULT hr; + UINT count = 0, size; + + hr = IStorage_EnumElements(sv->db->storage, 0, NULL, 0, &stgenum); + if (FAILED(hr)) + return -1; + + sv->max_storages = 1; + sv->storages = msi_alloc(sizeof(STORAGE *)); + if (!sv->storages) + return -1; + + while (TRUE) + { + size = 0; + hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &size); + if (FAILED(hr) || !size) + break; + + if (stat.type != STGTY_STORAGE) + { + CoTaskMemFree(stat.pwcsName); + continue; + } + + TRACE("enumerated storage %s\n", debugstr_w(stat.pwcsName)); + + storage = create_storage(sv, stat.pwcsName, NULL); + if (!storage) + { + count = -1; + CoTaskMemFree(stat.pwcsName); + break; + } + + IStorage_OpenStorage(sv->db->storage, stat.pwcsName, NULL, + STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0, + &storage->storage); + CoTaskMemFree(stat.pwcsName); + + if (!storages_set_table_size(sv, ++count)) + { + count = -1; + break; + } + + sv->storages[count - 1] = storage; + } + + IEnumSTATSTG_Release(stgenum); + return count; +} + +UINT STORAGES_CreateView(MSIDATABASE *db, MSIVIEW **view) +{ + MSISTORAGESVIEW *sv; + INT rows; + + TRACE("(%p, %p)\n", db, view); + + sv = msi_alloc(sizeof(MSISTORAGESVIEW)); + if (!sv) + return ERROR_FUNCTION_FAILED; + + sv->view.ops = &storages_ops; + sv->db = db; + + rows = add_storages_to_table(sv); + if (rows < 0) + return ERROR_FUNCTION_FAILED; + + sv->num_rows = rows; + + *view = (MSIVIEW *)sv; + + return ERROR_SUCCESS; +} diff --git a/dlls/msi/table.c b/dlls/msi/table.c index c3739e5..13c61d4 100644 --- a/dlls/msi/table.c +++ b/dlls/msi/table.c @@ -2109,11 +2109,14 @@ UINT TABLE_CreateView( MSIDATABASE *db, LPCWSTR name, MSIVIEW **view ) UINT r, sz; static const WCHAR Streams[] = {'_','S','t','r','e','a','m','s',0}; + static const WCHAR Storages[] = {'_','S','t','o','r','a','g','e','s',0}; TRACE("%p %s %p\n", db, debugstr_w(name), view ); if ( !lstrcmpW( name, Streams ) ) return STREAMS_CreateView( db, view ); + else if ( !lstrcmpW( name, Storages ) ) + return STORAGES_CreateView( db, view ); sz = sizeof *tv + lstrlenW(name)*sizeof name[0] ; tv = msi_alloc_zero( sz ); diff --git a/dlls/msi/tests/db.c b/dlls/msi/tests/db.c index 0b2dac4..10c2a4a 100644 --- a/dlls/msi/tests/db.c +++ b/dlls/msi/tests/db.c @@ -6054,22 +6054,16 @@ static void test_storages_table(void) /* check the column types */ hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES); ok(hrec, "failed to get column info hrecord\n"); - todo_wine - { - ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n"); - ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n"); - } + ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n"); + ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n"); MsiCloseHandle(hrec); /* now try the names */ hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES); ok(hrec, "failed to get column info hrecord\n"); - todo_wine - { - ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n"); - ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n"); - } + ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n"); + ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n"); MsiCloseHandle(hrec); @@ -6085,16 +6079,10 @@ static void test_storages_table(void) query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)"; r = MsiDatabaseOpenView(hdb, query, &hview); - todo_wine - { - ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r); - } + ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r); r = MsiViewExecute(hview, hrec); - todo_wine - { - ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r); - } + ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r); MsiCloseHandle(hrec); MsiViewClose(hview); @@ -6102,30 +6090,18 @@ static void test_storages_table(void) query = "SELECT `Name`, `Data` FROM `_Storages`"; r = MsiDatabaseOpenView(hdb, query, &hview); - todo_wine - { - ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r); - } + ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r); r = MsiViewExecute(hview, 0); - todo_wine - { - ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r); - } + ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r); r = MsiViewFetch(hview, &hrec); - todo_wine - { - ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r); - } + ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r); size = MAX_PATH; r = MsiRecordGetString(hrec, 1, file, &size); - todo_wine - { - ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r); - ok(!lstrcmp(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file); - } + ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r); + ok(!lstrcmp(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file); size = MAX_PATH; lstrcpyA(buf, "apple"); @@ -6140,10 +6116,7 @@ static void test_storages_table(void) MsiCloseHandle(hrec); r = MsiViewFetch(hview, &hrec); - todo_wine - { - ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r); - } + ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r); MsiViewClose(hview); MsiCloseHandle(hview); @@ -6160,28 +6133,21 @@ static void test_storages_table(void) MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH); hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0, &inner); - todo_wine - { - ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); - ok(inner != NULL, "Expected non-NULL storage\n"); - } + ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); + ok(inner != NULL, "Expected non-NULL storage\n"); - /* FIXME: remove when wine is fixed */ - if (inner) - { - MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH); - hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm); - ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); - ok(stm != NULL, "Expected non-NULL stream\n"); + MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH); + hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm); + ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); + ok(stm != NULL, "Expected non-NULL stream\n"); - hr = IStream_Read(stm, buf, MAX_PATH, &size); - ok(hr == S_OK, "Expected S_OK, got %d\n", hr); - ok(size == 8, "Expected 8, got %d\n", size); - ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf); + hr = IStream_Read(stm, buf, MAX_PATH, &size); + ok(hr == S_OK, "Expected S_OK, got %d\n", hr); + ok(size == 8, "Expected 8, got %d\n", size); + ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf); - IStream_Release(stm); - IStorage_Release(inner); - } + IStream_Release(stm); + IStorage_Release(inner); IStorage_Release(stg); DeleteFileA(msifile); -- 1.5.4.3