August 2020 - Wine-devel - list.winehq.org

[PATCH 1/2] msvcrt: Avoid allocations in _write implementation.
by Piotr Caban 05 Aug '20

05 Aug '20

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/file.c | 154 +++++++++++++-------------------------------- 1 file changed, 42 insertions(+), 112 deletions(-)

1 0

[PATCH] msvcrt: Return error on invalid character in mbstowcs.
by Piotr Caban 05 Aug '20

05 Aug '20

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/mbcs.c | 15 +++++++++++---- dlls/msvcrt/tests/string.c | 5 +++++ 2 files changed, 16 insertions(+), 4 deletions(-)

1 0

[v4 PATCH 1/5] combase: Move IMalloc/IMallocSpy functionality.
by Nikolay Sivov 05 Aug '20

05 Aug '20

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/combase/Makefile.in | 1 + dlls/combase/combase.spec | 12 +- dlls/combase/malloc.c | 456 +++++++++++++++++++++++++++++++++ dlls/ole32/ifs.c | 515 -------------------------------------- dlls/ole32/ole32.spec | 12 +- 5 files changed, 469 insertions(+), 527 deletions(-) create mode 100644 dlls/combase/malloc.c diff --git a/dlls/combase/Makefile.in b/dlls/combase/Makefile.in index 83c71ce9493..f2174f4e3eb 100644 --- a/dlls/combase/Makefile.in +++ b/dlls/combase/Makefile.in @@ -7,6 +7,7 @@ EXTRADLLFLAGS = -mno-cygwin C_SRCS = \ errorinfo.c \ + malloc.c \ roapi.c \ string.c \ usrmarshal.c diff --git a/dlls/combase/combase.spec b/dlls/combase/combase.spec index cb073ef2fcc..aa1c04ce0ac 100644 --- a/dlls/combase/combase.spec +++ b/dlls/combase/combase.spec @@ -109,7 +109,7 @@ @ stdcall CoGetInstanceFromFile(ptr ptr ptr long long wstr long ptr) ole32.CoGetInstanceFromFile @ stdcall CoGetInstanceFromIStorage(ptr ptr ptr long ptr long ptr) ole32.CoGetInstanceFromIStorage @ stdcall CoGetInterfaceAndReleaseStream(ptr ptr ptr) ole32.CoGetInterfaceAndReleaseStream -@ stdcall CoGetMalloc(long ptr) ole32.CoGetMalloc +@ stdcall CoGetMalloc(long ptr) @ stdcall CoGetMarshalSizeMax(ptr ptr ptr long ptr long) ole32.CoGetMarshalSizeMax @ stub CoGetModuleType @ stdcall CoGetObjectContext(ptr ptr) ole32.CoGetObjectContext @@ -139,7 +139,7 @@ @ stub CoRegisterActivationFilter @ stdcall CoRegisterClassObject(ptr ptr long long ptr) ole32.CoRegisterClassObject @ stdcall CoRegisterInitializeSpy(ptr ptr) ole32.CoRegisterInitializeSpy -@ stdcall CoRegisterMallocSpy(ptr) ole32.CoRegisterMallocSpy +@ stdcall CoRegisterMallocSpy(ptr) @ stdcall CoRegisterMessageFilter(ptr ptr) ole32.CoRegisterMessageFilter @ stdcall CoRegisterPSClsid(ptr ptr) ole32.CoRegisterPSClsid @ stdcall CoRegisterSurrogate(ptr) ole32.CoRegisterSurrogate @@ -151,15 +151,15 @@ @ stdcall CoRevertToSelf() ole32.CoRevertToSelf @ stdcall CoRevokeClassObject(long) ole32.CoRevokeClassObject @ stdcall CoRevokeInitializeSpy(int64) ole32.CoRevokeInitializeSpy -@ stdcall CoRevokeMallocSpy() ole32.CoRevokeMallocSpy +@ stdcall CoRevokeMallocSpy() @ stub CoSetCancelObject @ stub CoSetErrorInfo @ stdcall CoSetProxyBlanket(ptr long long ptr long long ptr long) ole32.CoSetProxyBlanket @ stdcall CoSuspendClassObjects() ole32.CoSuspendClassObjects @ stdcall CoSwitchCallContext(ptr ptr) ole32.CoSwitchCallContext -@ stdcall CoTaskMemAlloc(long) ole32.CoTaskMemAlloc -@ stdcall CoTaskMemFree(ptr) ole32.CoTaskMemFree -@ stdcall CoTaskMemRealloc(ptr long) ole32.CoTaskMemRealloc +@ stdcall CoTaskMemAlloc(long) +@ stdcall CoTaskMemFree(ptr) +@ stdcall CoTaskMemRealloc(ptr long) @ stub CoTestCancel @ stdcall CoUninitialize() ole32.CoUninitialize @ stub CoUnloadingWOW diff --git a/dlls/combase/malloc.c b/dlls/combase/malloc.c new file mode 100644 index 00000000000..2be03ae1e31 --- /dev/null +++ b/dlls/combase/malloc.c @@ -0,0 +1,456 @@ +/* + * Copyright 1997 Marcus Meissner + * + * 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 + */ + +#define COBJMACROS + +#include "oleauto.h" + +#include "wine/debug.h" +#include "wine/heap.h" + +WINE_DEFAULT_DEBUG_CHANNEL(olemalloc); + +static const IMallocVtbl allocator_vtbl; + +struct allocator +{ + IMalloc IMalloc_iface; + IMallocSpy *spy; + DWORD spyed_allocations; + BOOL spy_release_pending; /* CoRevokeMallocSpy called with spyed allocations left */ + void **blocks; + DWORD blocks_length; +}; + +static struct allocator allocator = { .IMalloc_iface.lpVtbl = &allocator_vtbl }; + +static CRITICAL_SECTION allocspy_cs; +static CRITICAL_SECTION_DEBUG allocspy_cs_debug = +{ + 0, 0, &allocspy_cs, + { &allocspy_cs_debug.ProcessLocksList, &allocspy_cs_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": allocspy_cs") } +}; +static CRITICAL_SECTION allocspy_cs = { &allocspy_cs_debug, -1, 0, 0, 0, 0 }; + +static BOOL mallocspy_grow(DWORD length) +{ + void **blocks; + + if (!allocator.blocks) blocks = LocalAlloc(LMEM_ZEROINIT, length * sizeof(void *)); + else blocks = LocalReAlloc(allocator.blocks, length * sizeof(void *), LMEM_ZEROINIT | LMEM_MOVEABLE); + if (blocks) + { + allocator.blocks = blocks; + allocator.blocks_length = length; + } + + return blocks != NULL; +} + +static void mallocspy_add_mem(void *mem) +{ + void **current; + + if (!mem || (!allocator.blocks_length && !mallocspy_grow(0x1000))) + return; + + /* Find a free location */ + current = allocator.blocks; + while (*current) + { + current++; + if (current >= allocator.blocks + allocator.blocks_length) + { + DWORD old_length = allocator.blocks_length; + if (!mallocspy_grow(allocator.blocks_length + 0x1000)) + return; + current = allocator.blocks + old_length; + } + } + + *current = mem; + allocator.spyed_allocations++; +} + +static void** mallocspy_is_allocation_spyed(const void *mem) +{ + void **current = allocator.blocks; + + while (*current != mem) + { + current++; + if (current >= allocator.blocks + allocator.blocks_length) + return NULL; + } + + return current; +} + +static BOOL mallocspy_remove_spyed_memory(const void *mem) +{ + void **current; + + if (!allocator.blocks_length) + return FALSE; + + if (!(current = mallocspy_is_allocation_spyed(mem))) + return FALSE; + + allocator.spyed_allocations--; + *current = NULL; + return TRUE; +} + +static HRESULT WINAPI allocator_QueryInterface(IMalloc *iface, REFIID riid, void **obj) +{ + TRACE("%s, %p.\n", debugstr_guid(riid), obj); + + if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMalloc, riid)) + { + *obj = &allocator.IMalloc_iface; + return S_OK; + } + + return E_NOINTERFACE; +} + +static ULONG WINAPI allocator_AddRef(IMalloc *iface) +{ + return 2; +} + +static ULONG WINAPI allocator_Release(IMalloc *iface) +{ + return 1; +} + +static void * WINAPI allocator_Alloc(IMalloc *iface, SIZE_T cb) +{ + void *addr; + + TRACE("%ld.\n", cb); + + if (allocator.spy) + { + SIZE_T preAllocResult; + + EnterCriticalSection(&allocspy_cs); + preAllocResult = IMallocSpy_PreAlloc(allocator.spy, cb); + if (cb && !preAllocResult) + { + /* PreAlloc can force Alloc to fail, but not if cb == 0 */ + TRACE("returning null\n"); + LeaveCriticalSection(&allocspy_cs); + return NULL; + } + } + + addr = HeapAlloc(GetProcessHeap(), 0, cb); + + if (allocator.spy) + { + addr = IMallocSpy_PostAlloc(allocator.spy, addr); + mallocspy_add_mem(addr); + LeaveCriticalSection(&allocspy_cs); + } + + TRACE("%p.\n",addr); + return addr; +} + +static void * WINAPI allocator_Realloc(IMalloc *iface, void *pv, SIZE_T cb) +{ + void *addr; + + TRACE("%p, %ld.\n",pv,cb); + + if (allocator.spy) + { + void *real_mem; + BOOL spyed; + + EnterCriticalSection(&allocspy_cs); + spyed = mallocspy_remove_spyed_memory(pv); + cb = IMallocSpy_PreRealloc(allocator.spy, pv, cb, &real_mem, spyed); + + /* check if can release the spy */ + if (allocator.spy_release_pending && !allocator.spyed_allocations) + { + IMallocSpy_Release(allocator.spy); + allocator.spy_release_pending = FALSE; + allocator.spy = NULL; + LeaveCriticalSection(&allocspy_cs); + } + + if (!cb) + { + /* PreRealloc can force Realloc to fail */ + if (allocator.spy) + LeaveCriticalSection(&allocspy_cs); + return NULL; + } + + pv = real_mem; + } + + if (!pv) addr = HeapAlloc(GetProcessHeap(), 0, cb); + else if (cb) addr = HeapReAlloc(GetProcessHeap(), 0, pv, cb); + else + { + HeapFree(GetProcessHeap(), 0, pv); + addr = NULL; + } + + if (allocator.spy) + { + addr = IMallocSpy_PostRealloc(allocator.spy, addr, TRUE); + mallocspy_add_mem(addr); + LeaveCriticalSection(&allocspy_cs); + } + + TRACE("%p.\n", addr); + return addr; +} + +static void WINAPI allocator_Free(IMalloc *iface, void *mem) +{ + BOOL spyed_block = FALSE, spy_active = FALSE; + + TRACE("%p.\n", mem); + + if (!mem) + return; + + if (allocator.spy) + { + EnterCriticalSection(&allocspy_cs); + spyed_block = mallocspy_remove_spyed_memory(mem); + spy_active = TRUE; + mem = IMallocSpy_PreFree(allocator.spy, mem, spyed_block); + } + + HeapFree(GetProcessHeap(), 0, mem); + + if (spy_active) + { + IMallocSpy_PostFree(allocator.spy, spyed_block); + + /* check if can release the spy */ + if (allocator.spy_release_pending && !allocator.spyed_allocations) + { + IMallocSpy_Release(allocator.spy); + allocator.spy_release_pending = FALSE; + allocator.spy = NULL; + } + + LeaveCriticalSection(&allocspy_cs); + } +} + +/****************************************************************************** + * NOTES + * FIXME returns: + * win95: size allocated (4 byte boundaries) + * win2k: size originally requested !!! (allocated on 8 byte boundaries) + */ +static SIZE_T WINAPI allocator_GetSize(IMalloc *iface, void *mem) +{ + BOOL spyed_block = FALSE, spy_active = FALSE; + SIZE_T size; + + TRACE("%p.\n", mem); + + if (!mem) + return (SIZE_T)-1; + + if (allocator.spy) + { + EnterCriticalSection(&allocspy_cs); + spyed_block = !!mallocspy_is_allocation_spyed(mem); + spy_active = TRUE; + mem = IMallocSpy_PreGetSize(allocator.spy, mem, spyed_block); + } + + size = HeapSize(GetProcessHeap(), 0, mem); + + if (spy_active) + { + size = IMallocSpy_PostGetSize(allocator.spy, size, spyed_block); + LeaveCriticalSection(&allocspy_cs); + } + + return size; +} + +static INT WINAPI allocator_DidAlloc(IMalloc *iface, void *mem) +{ + BOOL spyed_block = FALSE, spy_active = FALSE; + int did_alloc; + + TRACE("%p.\n", mem); + + if (!mem) + return -1; + + if (allocator.spy) + { + EnterCriticalSection(&allocspy_cs); + spyed_block = !!mallocspy_is_allocation_spyed(mem); + spy_active = TRUE; + mem = IMallocSpy_PreDidAlloc(allocator.spy, mem, spyed_block); + } + + did_alloc = HeapValidate(GetProcessHeap(), 0, mem); + + if (spy_active) + { + did_alloc = IMallocSpy_PostDidAlloc(allocator.spy, mem, spyed_block, did_alloc); + LeaveCriticalSection(&allocspy_cs); + } + + return did_alloc; +} + +static void WINAPI allocator_HeapMinimize(IMalloc *iface) +{ + BOOL spy_active = FALSE; + + TRACE("\n"); + + if (allocator.spy) + { + EnterCriticalSection(&allocspy_cs); + spy_active = TRUE; + IMallocSpy_PreHeapMinimize(allocator.spy); + } + + if (spy_active) + { + IMallocSpy_PostHeapMinimize(allocator.spy); + LeaveCriticalSection(&allocspy_cs); + } +} + +static const IMallocVtbl allocator_vtbl = +{ + allocator_QueryInterface, + allocator_AddRef, + allocator_Release, + allocator_Alloc, + allocator_Realloc, + allocator_Free, + allocator_GetSize, + allocator_DidAlloc, + allocator_HeapMinimize +}; + +/****************************************************************************** + * CoGetMalloc (combase.@) + */ +HRESULT WINAPI CoGetMalloc(DWORD context, IMalloc **imalloc) +{ + if (context != MEMCTX_TASK) + { + *imalloc = NULL; + return E_INVALIDARG; + } + + *imalloc = &allocator.IMalloc_iface; + + return S_OK; +} + +/*********************************************************************** + * CoTaskMemAlloc (combase.@) + */ +void * WINAPI CoTaskMemAlloc(SIZE_T size) +{ + return IMalloc_Alloc(&allocator.IMalloc_iface, size); +} + +/*********************************************************************** + * CoTaskMemFree (combase.@) + */ +void WINAPI CoTaskMemFree(void *ptr) +{ + IMalloc_Free(&allocator.IMalloc_iface, ptr); +} + +/*********************************************************************** + * CoTaskMemRealloc (combase.@) + */ +void * WINAPI CoTaskMemRealloc(void *ptr, SIZE_T size) +{ + return IMalloc_Realloc(&allocator.IMalloc_iface, ptr, size); +} + +/*********************************************************************** + * CoRegisterMallocSpy (combase.@) + */ +HRESULT WINAPI CoRegisterMallocSpy(IMallocSpy *spy) +{ + HRESULT hr = E_INVALIDARG; + + TRACE("%p.\n", spy); + + if (!spy) return E_INVALIDARG; + + EnterCriticalSection(&allocspy_cs); + + if (allocator.spy) + hr = CO_E_OBJISREG; + else if (SUCCEEDED(IMallocSpy_QueryInterface(spy, &IID_IMallocSpy, (void **)&spy))) + { + allocator.spy = spy; + hr = S_OK; + } + + LeaveCriticalSection(&allocspy_cs); + + return hr; +} + +/*********************************************************************** + * CoRevokeMallocSpy (combase.@) + */ +HRESULT WINAPI CoRevokeMallocSpy(void) +{ + HRESULT hr = S_OK; + + TRACE("\n"); + + EnterCriticalSection(&allocspy_cs); + + if (!allocator.spy) + hr = CO_E_OBJNOTREG; + else if (allocator.spyed_allocations) + { + allocator.spy_release_pending = TRUE; + hr = E_ACCESSDENIED; + } + else + { + IMallocSpy_Release(allocator.spy); + allocator.spy = NULL; + } + + LeaveCriticalSection(&allocspy_cs); + + return hr; +} diff --git a/dlls/ole32/ifs.c b/dlls/ole32/ifs.c index a144833c7af..845bdeea4a5 100644 --- a/dlls/ole32/ifs.c +++ b/dlls/ole32/ifs.c @@ -32,521 +32,6 @@ #include "ole2.h" #include "winerror.h" -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(olemalloc); - -/****************************************************************************** - * IMalloc32 implementation - * - * NOTES - * For supporting CoRegisterMallocSpy the IMalloc implementation must know if - * a given memory block was allocated with a spy active. - * - *****************************************************************************/ -/* set the vtable later */ -static const IMallocVtbl VT_IMalloc32; - -struct allocator -{ - IMalloc IMalloc_iface; - IMallocSpy * pSpy; /* the spy when active */ - DWORD SpyedAllocationsLeft; /* number of spyed allocations left */ - BOOL SpyReleasePending; /* CoRevokeMallocSpy called with spyed allocations left*/ - LPVOID * SpyedBlocks; /* root of the table */ - DWORD SpyedBlockTableLength;/* size of the table*/ -}; - -static struct allocator Malloc32 = { .IMalloc_iface.lpVtbl = &VT_IMalloc32 }; - -/* with a spy active all calls from pre to post methods are threadsafe */ -static CRITICAL_SECTION IMalloc32_SpyCS; -static CRITICAL_SECTION_DEBUG critsect_debug = -{ - 0, 0, &IMalloc32_SpyCS, - { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList }, - 0, 0, { (DWORD_PTR)(__FILE__ ": IMalloc32_SpyCS") } -}; -static CRITICAL_SECTION IMalloc32_SpyCS = { &critsect_debug, -1, 0, 0, 0, 0 }; - -/* resize the old table */ -static BOOL SetSpyedBlockTableLength ( DWORD NewLength ) -{ - LPVOID *NewSpyedBlocks; - - if (!Malloc32.SpyedBlocks) NewSpyedBlocks = LocalAlloc(LMEM_ZEROINIT, NewLength * sizeof(PVOID)); - else NewSpyedBlocks = LocalReAlloc(Malloc32.SpyedBlocks, NewLength * sizeof(PVOID), LMEM_ZEROINIT | LMEM_MOVEABLE); - if (NewSpyedBlocks) { - Malloc32.SpyedBlocks = NewSpyedBlocks; - Malloc32.SpyedBlockTableLength = NewLength; - } - - return NewSpyedBlocks != NULL; -} - -/* add a location to the table */ -static BOOL AddMemoryLocation(LPVOID * pMem) -{ - LPVOID * Current; - - /* allocate the table if not already allocated */ - if (!Malloc32.SpyedBlockTableLength && !SetSpyedBlockTableLength(0x1000)) - return FALSE; - - /* find a free location */ - Current = Malloc32.SpyedBlocks; - while (*Current) { - Current++; - if (Current >= Malloc32.SpyedBlocks + Malloc32.SpyedBlockTableLength) { - /* no more space in table, grow it */ - DWORD old_length = Malloc32.SpyedBlockTableLength; - if (!SetSpyedBlockTableLength( Malloc32.SpyedBlockTableLength + 0x1000)) - return FALSE; - Current = Malloc32.SpyedBlocks + old_length; - } - }; - - /* put the location in our table */ - *Current = pMem; - Malloc32.SpyedAllocationsLeft++; - /*TRACE("%lu\n",Malloc32.SpyedAllocationsLeft);*/ - return TRUE; -} - -static void** mallocspy_is_allocation_spyed(const void *mem) -{ - void **current = Malloc32.SpyedBlocks; - - while (*current != mem) - { - current++; - if (current >= Malloc32.SpyedBlocks + Malloc32.SpyedBlockTableLength) - return NULL; - } - - return current; -} - -static BOOL mallocspy_remove_spyed_memory(const void *mem) -{ - void **current; - - if (!Malloc32.SpyedBlockTableLength) - return FALSE; - - if (!(current = mallocspy_is_allocation_spyed(mem))) - return FALSE; - - Malloc32.SpyedAllocationsLeft--; - *current = NULL; - return TRUE; -} - -/****************************************************************************** - * IMalloc32_QueryInterface [VTABLE] - */ -static HRESULT WINAPI IMalloc_fnQueryInterface(IMalloc *iface, REFIID refiid, void **obj) -{ - TRACE("(%s,%p)\n",debugstr_guid(refiid),obj); - - if (IsEqualIID(&IID_IUnknown,refiid) || IsEqualIID(&IID_IMalloc,refiid)) { - *obj = &Malloc32; - return S_OK; - } - return E_NOINTERFACE; -} - -/****************************************************************************** - * IMalloc32_AddRefRelease [VTABLE] - */ -static ULONG WINAPI IMalloc_fnAddRefRelease(IMalloc *iface) -{ - return 1; -} - -/****************************************************************************** - * IMalloc32_Alloc [VTABLE] - */ -static void * WINAPI IMalloc_fnAlloc(IMalloc *iface, SIZE_T cb) -{ - void *addr; - - TRACE("(%ld)\n",cb); - - if(Malloc32.pSpy) { - SIZE_T preAllocResult; - - EnterCriticalSection(&IMalloc32_SpyCS); - preAllocResult = IMallocSpy_PreAlloc(Malloc32.pSpy, cb); - if ((cb != 0) && (preAllocResult == 0)) { - /* PreAlloc can force Alloc to fail, but not if cb == 0 */ - TRACE("returning null\n"); - LeaveCriticalSection(&IMalloc32_SpyCS); - return NULL; - } - } - - addr = HeapAlloc(GetProcessHeap(),0,cb); - - if(Malloc32.pSpy) { - addr = IMallocSpy_PostAlloc(Malloc32.pSpy, addr); - if (addr) AddMemoryLocation(addr); - LeaveCriticalSection(&IMalloc32_SpyCS); - } - - TRACE("--(%p)\n",addr); - return addr; -} - -/****************************************************************************** - * IMalloc32_Realloc [VTABLE] - */ -static void * WINAPI IMalloc_fnRealloc(IMalloc *iface, void *pv, SIZE_T cb) -{ - void *pNewMemory; - - TRACE("(%p,%ld)\n",pv,cb); - - if(Malloc32.pSpy) { - void *pRealMemory; - BOOL fSpyed; - - EnterCriticalSection(&IMalloc32_SpyCS); - fSpyed = mallocspy_remove_spyed_memory(pv); - cb = IMallocSpy_PreRealloc(Malloc32.pSpy, pv, cb, &pRealMemory, fSpyed); - - /* check if can release the spy */ - if(Malloc32.SpyReleasePending && !Malloc32.SpyedAllocationsLeft) { - IMallocSpy_Release(Malloc32.pSpy); - Malloc32.SpyReleasePending = FALSE; - Malloc32.pSpy = NULL; - LeaveCriticalSection(&IMalloc32_SpyCS); - } - - if (0==cb) { - /* PreRealloc can force Realloc to fail */ - if (Malloc32.pSpy) - LeaveCriticalSection(&IMalloc32_SpyCS); - return NULL; - } - - pv = pRealMemory; - } - - if (!pv) pNewMemory = HeapAlloc(GetProcessHeap(),0,cb); - else if (cb) pNewMemory = HeapReAlloc(GetProcessHeap(),0,pv,cb); - else { - HeapFree(GetProcessHeap(),0,pv); - pNewMemory = NULL; - } - - if(Malloc32.pSpy) { - pNewMemory = IMallocSpy_PostRealloc(Malloc32.pSpy, pNewMemory, TRUE); - if (pNewMemory) AddMemoryLocation(pNewMemory); - LeaveCriticalSection(&IMalloc32_SpyCS); - } - - TRACE("--(%p)\n",pNewMemory); - return pNewMemory; -} - -/****************************************************************************** - * IMalloc32_Free [VTABLE] - */ -static void WINAPI IMalloc_fnFree(IMalloc *iface, void *mem) -{ - BOOL spyed_block = FALSE, spy_active = FALSE; - - TRACE("(%p)\n", mem); - - if (!mem) - return; - - if (Malloc32.pSpy) - { - EnterCriticalSection(&IMalloc32_SpyCS); - spyed_block = mallocspy_remove_spyed_memory(mem); - spy_active = TRUE; - mem = IMallocSpy_PreFree(Malloc32.pSpy, mem, spyed_block); - } - - HeapFree(GetProcessHeap(), 0, mem); - - if (spy_active) - { - IMallocSpy_PostFree(Malloc32.pSpy, spyed_block); - - /* check if can release the spy */ - if (Malloc32.SpyReleasePending && !Malloc32.SpyedAllocationsLeft) - { - IMallocSpy_Release(Malloc32.pSpy); - Malloc32.SpyReleasePending = FALSE; - Malloc32.pSpy = NULL; - } - - LeaveCriticalSection(&IMalloc32_SpyCS); - } -} - -/****************************************************************************** - * IMalloc32_GetSize [VTABLE] - * - * NOTES - * FIXME returns: - * win95: size allocated (4 byte boundaries) - * win2k: size originally requested !!! (allocated on 8 byte boundaries) - */ -static SIZE_T WINAPI IMalloc_fnGetSize(IMalloc *iface, void *mem) -{ - BOOL spyed_block = FALSE, spy_active = FALSE; - SIZE_T size; - - TRACE("(%p)\n", mem); - - if (!mem) - return (SIZE_T)-1; - - if (Malloc32.pSpy) - { - EnterCriticalSection(&IMalloc32_SpyCS); - spyed_block = !!mallocspy_is_allocation_spyed(mem); - spy_active = TRUE; - mem = IMallocSpy_PreGetSize(Malloc32.pSpy, mem, spyed_block); - } - - size = HeapSize(GetProcessHeap(), 0, mem); - - if (spy_active) - { - size = IMallocSpy_PostGetSize(Malloc32.pSpy, size, spyed_block); - LeaveCriticalSection(&IMalloc32_SpyCS); - } - - return size; -} - -/****************************************************************************** - * IMalloc32_DidAlloc [VTABLE] - */ -static INT WINAPI IMalloc_fnDidAlloc(IMalloc *iface, void *mem) -{ - BOOL spyed_block = FALSE, spy_active = FALSE; - int did_alloc; - - TRACE("(%p)\n", mem); - - if (!mem) - return -1; - - if (Malloc32.pSpy) - { - EnterCriticalSection(&IMalloc32_SpyCS); - spyed_block = !!mallocspy_is_allocation_spyed(mem); - spy_active = TRUE; - mem = IMallocSpy_PreDidAlloc(Malloc32.pSpy, mem, spyed_block); - } - - did_alloc = HeapValidate(GetProcessHeap(), 0, mem); - - if (spy_active) - { - did_alloc = IMallocSpy_PostDidAlloc(Malloc32.pSpy, mem, spyed_block, did_alloc); - LeaveCriticalSection(&IMalloc32_SpyCS); - } - - return did_alloc; -} - -/****************************************************************************** - * IMalloc32_HeapMinimize [VTABLE] - */ -static void WINAPI IMalloc_fnHeapMinimize(IMalloc *iface) -{ - BOOL spy_active = FALSE; - - TRACE("()\n"); - - if (Malloc32.pSpy) - { - EnterCriticalSection(&IMalloc32_SpyCS); - spy_active = TRUE; - IMallocSpy_PreHeapMinimize(Malloc32.pSpy); - } - - if (spy_active) - { - IMallocSpy_PostHeapMinimize(Malloc32.pSpy); - LeaveCriticalSection(&IMalloc32_SpyCS); - } -} - -static const IMallocVtbl VT_IMalloc32 = -{ - IMalloc_fnQueryInterface, - IMalloc_fnAddRefRelease, - IMalloc_fnAddRefRelease, - IMalloc_fnAlloc, - IMalloc_fnRealloc, - IMalloc_fnFree, - IMalloc_fnGetSize, - IMalloc_fnDidAlloc, - IMalloc_fnHeapMinimize -}; - -/****************************************************************************** - * CoGetMalloc [OLE32.@] - * - * Retrieves the current IMalloc interface for the process. - * - * PARAMS - * context [I] Should always be MEMCTX_TASK. - * imalloc [O] Address where memory allocator object will be stored. - * - * RETURNS - * Success: S_OK. - * Failure: HRESULT code. - */ -HRESULT WINAPI CoGetMalloc(DWORD context, IMalloc **imalloc) -{ - if (context != MEMCTX_TASK) { - *imalloc = NULL; - return E_INVALIDARG; - } - - *imalloc = &Malloc32.IMalloc_iface; - return S_OK; -} - -/*********************************************************************** - * CoTaskMemAlloc [OLE32.@] - * - * Allocates memory using the current process memory allocator. - * - * PARAMS - * size [I] Size of the memory block to allocate. - * - * RETURNS - * Success: Pointer to newly allocated memory block. - * Failure: NULL. - */ -LPVOID WINAPI CoTaskMemAlloc(SIZE_T size) -{ - return IMalloc_Alloc(&Malloc32.IMalloc_iface,size); -} - -/*********************************************************************** - * CoTaskMemFree [OLE32.@] - * - * Frees memory allocated from the current process memory allocator. - * - * PARAMS - * ptr [I] Memory block to free. - * - * RETURNS - * Nothing. - */ -VOID WINAPI CoTaskMemFree(LPVOID ptr) -{ - IMalloc_Free(&Malloc32.IMalloc_iface, ptr); -} - -/*********************************************************************** - * CoTaskMemRealloc [OLE32.@] - * - * Allocates memory using the current process memory allocator. - * - * PARAMS - * pvOld [I] Pointer to old memory block. - * size [I] Size of the new memory block. - * - * RETURNS - * Success: Pointer to newly allocated memory block. - * Failure: NULL. - */ -LPVOID WINAPI CoTaskMemRealloc(LPVOID pvOld, SIZE_T size) -{ - return IMalloc_Realloc(&Malloc32.IMalloc_iface, pvOld, size); -} - -/*********************************************************************** - * CoRegisterMallocSpy [OLE32.@] - * - * Registers an object that receives notifications on memory allocations and - * frees. - * - * PARAMS - * pMallocSpy [I] New spy object. - * - * RETURNS - * Success: S_OK. - * Failure: HRESULT code. - * - * NOTES - * if a mallocspy is already registered, we can't do it again since - * only the spy knows, how to free a memory block - */ -HRESULT WINAPI CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy) -{ - IMallocSpy* pSpy; - HRESULT hres = E_INVALIDARG; - - TRACE("%p\n", pMallocSpy); - - if(!pMallocSpy) return E_INVALIDARG; - - EnterCriticalSection(&IMalloc32_SpyCS); - - if (Malloc32.pSpy) - hres = CO_E_OBJISREG; - else if (SUCCEEDED(IMallocSpy_QueryInterface(pMallocSpy, &IID_IMallocSpy, (void**)&pSpy))) { - Malloc32.pSpy = pSpy; - hres = S_OK; - } - - LeaveCriticalSection(&IMalloc32_SpyCS); - - return hres; -} - -/*********************************************************************** - * CoRevokeMallocSpy [OLE32.@] - * - * Revokes a previously registered object that receives notifications on memory - * allocations and frees. - * - * PARAMS - * pMallocSpy [I] New spy object. - * - * RETURNS - * Success: S_OK. - * Failure: HRESULT code. - * - * NOTES - * we can't revoke a malloc spy as long as memory blocks allocated with - * the spy are active since only the spy knows how to free them - */ -HRESULT WINAPI CoRevokeMallocSpy(void) -{ - HRESULT hres = S_OK; - TRACE("\n"); - - EnterCriticalSection(&IMalloc32_SpyCS); - - if (!Malloc32.pSpy) - hres = CO_E_OBJNOTREG; - else if (Malloc32.SpyedAllocationsLeft) { - TRACE("SpyReleasePending with %u allocations left\n", Malloc32.SpyedAllocationsLeft); - Malloc32.SpyReleasePending = TRUE; - hres = E_ACCESSDENIED; - } else { - IMallocSpy_Release(Malloc32.pSpy); - Malloc32.pSpy = NULL; - } - LeaveCriticalSection(&IMalloc32_SpyCS); - - return hres; -} - /****************************************************************************** * IsValidInterface [OLE32.@] * diff --git a/dlls/ole32/ole32.spec b/dlls/ole32/ole32.spec index 927a98ea123..78e8641cf36 100644 --- a/dlls/ole32/ole32.spec +++ b/dlls/ole32/ole32.spec @@ -38,7 +38,7 @@ @ stdcall CoGetInstanceFromFile(ptr ptr ptr long long wstr long ptr) @ stdcall CoGetInstanceFromIStorage(ptr ptr ptr long ptr long ptr) @ stdcall CoGetInterfaceAndReleaseStream(ptr ptr ptr) -@ stdcall CoGetMalloc(long ptr) +@ stdcall CoGetMalloc(long ptr) combase.CoGetMalloc @ stdcall CoGetMarshalSizeMax(ptr ptr ptr long ptr long) @ stdcall CoGetObject(wstr ptr ptr ptr) @ stdcall CoGetObjectContext(ptr ptr) @@ -67,7 +67,7 @@ @ stdcall CoRegisterChannelHook(ptr ptr) @ stdcall CoRegisterClassObject(ptr ptr long long ptr) @ stdcall CoRegisterInitializeSpy(ptr ptr) -@ stdcall CoRegisterMallocSpy (ptr) +@ stdcall CoRegisterMallocSpy(ptr) combase.CoRegisterMallocSpy @ stdcall CoRegisterMessageFilter(ptr ptr) @ stdcall CoRegisterPSClsid(ptr ptr) @ stdcall CoRegisterSurrogate(ptr) @@ -78,14 +78,14 @@ @ stdcall CoRevertToSelf() @ stdcall CoRevokeClassObject(long) @ stdcall CoRevokeInitializeSpy(int64) -@ stdcall CoRevokeMallocSpy() +@ stdcall CoRevokeMallocSpy() combase.CoRevokeMallocSpy @ stdcall CoSetProxyBlanket(ptr long long ptr long long ptr long) @ stdcall CoSetState(ptr) @ stdcall CoSuspendClassObjects() @ stdcall CoSwitchCallContext(ptr ptr) -@ stdcall CoTaskMemAlloc(long) -@ stdcall CoTaskMemFree(ptr) -@ stdcall CoTaskMemRealloc(ptr long) +@ stdcall CoTaskMemAlloc(long) combase.CoTaskMemAlloc +@ stdcall CoTaskMemFree(ptr) combase.CoTaskMemFree +@ stdcall CoTaskMemRealloc(ptr long) combase.CoTaskMemRealloc @ stdcall CoTreatAsClass(ptr ptr) @ stdcall CoUninitialize() @ stub CoUnloadingWOW -- 2.27.0

3 11

[PATCH 2/2] xactengine3_7: Implement IXACT3Cue Interface.
by Vijay Kiran Kamuju 05 Aug '20

05 Aug '20

Based on patch from Ethan Lee. Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com>

2 1

[PATCH 1/2] xactengine3_7: Implement IXACT3SoundBank Interface.
by Vijay Kiran Kamuju 05 Aug '20

05 Aug '20

Based on patch from Ethan Lee. Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com>

2 1

[PATCH v2] wininet: Implement INTERNET_OPTION_SECURITY_CERTIFICATE flag for InternetQueryOption.
by Daniel Lehman 05 Aug '20

05 Aug '20

Signed-off-by: Daniel Lehman <dlehman25(a)gmail.com> --- v2: remove FIXME --- dlls/wininet/http.c | 60 ++++++++++++++++++ dlls/wininet/resource.h | 3 + dlls/wininet/tests/http.c | 127 +++++++++++++++++++++++++++++++++++++- dlls/wininet/wininet.rc | 11 ++++ 4 files changed, 199 insertions(+), 2 deletions(-) diff --git a/dlls/wininet/http.c b/dlls/wininet/http.c index 220493718c..635fc055b3 100644 --- a/dlls/wininet/http.c +++ b/dlls/wininet/http.c @@ -54,6 +54,7 @@ #include "internet.h" #include "zlib.h" +#include "resource.h" #include "wine/debug.h" #include "wine/exception.h" @@ -2277,6 +2278,65 @@ static DWORD HTTPREQ_QueryOption(object_header_t *hdr, DWORD option, void *buffe return get_security_cert_struct(req, (INTERNET_CERTIFICATE_INFOA*)buffer); } + case INTERNET_OPTION_SECURITY_CERTIFICATE: { + DWORD err; + int needed; + char fmt[512]; + char strength[16]; + char start_date[32]; + char start_time[32]; + char expiry_date[32]; + char expiry_time[32]; + SYSTEMTIME start, expiry; + INTERNET_CERTIFICATE_INFOA info; + + if(!size) + return ERROR_INVALID_PARAMETER; + + if(!req->netconn) { + *size = 0; + return ERROR_INTERNET_INVALID_OPERATION; + } + + if(!buffer) { + *size = 1; + return ERROR_INSUFFICIENT_BUFFER; + } + + if((err = get_security_cert_struct(req, &info))) + return err; + + LoadStringA(WININET_hModule, IDS_CERT_FORMAT, fmt, sizeof(fmt)); + LoadStringA(WININET_hModule, info.dwKeySize >= 128 ? IDS_CERT_HIGH : IDS_CERT_LOW, + strength, sizeof(strength)); + + FileTimeToSystemTime(&info.ftStart, &start); + FileTimeToSystemTime(&info.ftExpiry, &expiry); + GetDateFormatA(LOCALE_USER_DEFAULT, 0, &start, NULL, start_date, sizeof(start_date)); + GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &start, NULL, start_time, sizeof(start_time)); + GetDateFormatA(LOCALE_USER_DEFAULT, 0, &expiry, NULL, expiry_date, sizeof(expiry_date)); + GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &expiry, NULL, expiry_time, sizeof(expiry_time)); + + needed = _scprintf(fmt, info.lpszSubjectInfo, info.lpszIssuerInfo, + start_date, start_time, expiry_date, expiry_time, + strength, info.dwKeySize); + if(needed < *size) { + err = ERROR_SUCCESS; + *size = snprintf(buffer, *size, fmt, info.lpszSubjectInfo, info.lpszIssuerInfo, + start_date, start_time, expiry_date, expiry_time, + strength, info.dwKeySize); + }else { + err = ERROR_INSUFFICIENT_BUFFER; + *size = 1; + } + + LocalFree(info.lpszSubjectInfo); + LocalFree(info.lpszIssuerInfo); + LocalFree(info.lpszProtocolName); + LocalFree(info.lpszSignatureAlgName); + LocalFree(info.lpszEncryptionAlgName); + return err; + } case INTERNET_OPTION_CONNECT_TIMEOUT: if (*size < sizeof(DWORD)) return ERROR_INSUFFICIENT_BUFFER; diff --git a/dlls/wininet/resource.h b/dlls/wininet/resource.h index 256a374af0..190d3cc397 100644 --- a/dlls/wininet/resource.h +++ b/dlls/wininet/resource.h @@ -38,3 +38,6 @@ #define IDS_CERT_DATE_INVALID 0x502 #define IDS_CERT_CN_INVALID 0x503 #define IDS_CERT_ERRORS 0x504 +#define IDS_CERT_FORMAT 0x505 +#define IDS_CERT_HIGH 0x506 +#define IDS_CERT_LOW 0x507 diff --git a/dlls/wininet/tests/http.c b/dlls/wininet/tests/http.c index c07d60d2a9..e0a38e05c4 100644 --- a/dlls/wininet/tests/http.c +++ b/dlls/wininet/tests/http.c @@ -6112,9 +6112,26 @@ static const cert_struct_test_t test_winehq_com_cert = { "webmaster(a)winehq.org" }; +static const char *cert_string_fmt = + "Subject:\r\n%s\r\n" + "Issuer:\r\n%s\r\n" + "Effective Date:\t%s %s\r\n" + "Expiration Date:\t%s %s\r\n" + "Security Protocol:\t%s\r\n" + "Signature Type:\t%s\r\n" + "Encryption Type:\t%s\r\n" + "Privacy Strength:\t%s (%u bits)"; + static void test_cert_struct(HINTERNET req, const cert_struct_test_t *test) { INTERNET_CERTIFICATE_INFOA info; + SYSTEMTIME start, expiry; + char expiry_date[32]; + char expiry_time[32]; + char start_date[32]; + char start_time[32]; + char expect[512]; + char actual[512]; DWORD size; BOOL res; @@ -6138,6 +6155,42 @@ static void test_cert_struct(HINTERNET req, const cert_struct_test_t *test) ok(!info.lpszProtocolName, "lpszProtocolName = %s\n", info.lpszProtocolName); ok(info.dwKeySize >= 128 && info.dwKeySize <= 256, "dwKeySize = %u\n", info.dwKeySize); + if (PRIMARYLANGID(GetUserDefaultLangID()) != LANG_ENGLISH) + { + skip("Non-English locale (test with hardcoded English)\n"); + release_cert_info(&info); + return; + } + + size = sizeof(actual); + SetLastError(0xdeadbeef); + memset(actual, 0x55, sizeof(actual)); + res = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE, actual, &size); + ok(res, "InternetQueryOption failed: %u\n", GetLastError()); + + FileTimeToSystemTime(&info.ftStart, &start); + FileTimeToSystemTime(&info.ftExpiry, &expiry); + + GetDateFormatA(LOCALE_USER_DEFAULT, 0, &start, NULL, start_date, sizeof(start_date)); + GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &start, NULL, start_time, sizeof(start_time)); + GetDateFormatA(LOCALE_USER_DEFAULT, 0, &expiry, NULL, expiry_date, sizeof(expiry_date)); + GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &expiry, NULL, expiry_time, sizeof(expiry_time)); + + snprintf(expect, sizeof(expect), cert_string_fmt, info.lpszSubjectInfo, info.lpszIssuerInfo, + start_date, start_time, expiry_date, expiry_time, + info.lpszSignatureAlgName, info.lpszEncryptionAlgName, info.lpszProtocolName, + info.dwKeySize >= 128 ? "High" : "Low", info.dwKeySize); + ok(size == strlen(actual), "size = %u\n", size); + ok(!strcmp(actual, expect), "cert = actual\n%s\n", actual); + + --size; + SetLastError(0xdeadbeef); + memset(actual, 0x55, sizeof(actual)); + res = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE, actual, &size); + ok(!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError()); + ok(size == 1, "unexpected size: %u\n", size); + ok(actual[0] == 0x55, "unexpected byte: %02x\n", actual[0]); + release_cert_info(&info); } @@ -6217,7 +6270,7 @@ static void test_security_flags(void) INTERNET_CERTIFICATE_INFOA *cert; HINTERNET ses, conn, req; DWORD size, flags; - char buf[100]; + char buf[512]; BOOL res; if (!https_support) @@ -6378,6 +6431,30 @@ static void test_security_flags(void) } HeapFree(GetProcessHeap(), 0, cert); + SetLastError(0xdeadbeef); + res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE, NULL, NULL); + ok(!res && GetLastError() == ERROR_INVALID_PARAMETER, "InternetQueryOption failed: %d\n", GetLastError()); + + size = 0; + SetLastError(0xdeadbeef); + res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE, NULL, &size); + ok(!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError()); + ok(size == 1, "unexpected size: %u\n", size); + + size = 42; + SetLastError(0xdeadbeef); + memset(buf, 0x55, sizeof(buf)); + res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE, buf, &size); + ok(!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError()); + ok(size == 1, "unexpected size: %u\n", size); + ok(buf[0] == 0x55, "unexpected byte: %02x\n", buf[0]); + + size = sizeof(buf); + SetLastError(0xdeadbeef); + res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE, buf, &size); + ok(res && GetLastError() == ERROR_SUCCESS, "InternetQueryOption failed: %d\n", GetLastError()); + ok(size < sizeof(buf), "unexpected size: %u\n", size); + CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTING_TO_SERVER, 2); CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTED_TO_SERVER, 2); CHECK_NOTIFIED2(INTERNET_STATUS_CLOSING_CONNECTION, 2); @@ -6562,9 +6639,10 @@ static void test_secure_connection(void) static const WCHAR get[] = {'G','E','T',0}; static const WCHAR testpage[] = {'/','t','e','s','t','s','/','h','e','l','l','o','.','h','t','m','l',0}; HINTERNET ses, con, req; - DWORD size, flags, err; + DWORD size, size2, flags, err; INTERNET_CERTIFICATE_INFOA *certificate_structA = NULL; INTERNET_CERTIFICATE_INFOW *certificate_structW = NULL; + char certstr1[512], certstr2[512]; BOOL ret; ses = InternetOpenA("Gizmo5", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); @@ -6629,6 +6707,19 @@ static void test_secure_connection(void) } HeapFree(GetProcessHeap(), 0, certificate_structW); + SetLastError(0xdeadbeef); + size = sizeof(certstr1); + ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE, certstr1, &size); + ok(ret && GetLastError() == ERROR_SUCCESS, "InternetQueryOption failed: %d\n", GetLastError()); + + SetLastError(0xdeadbeef); + size2 = sizeof(certstr2); + ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE, certstr2, &size2); + ok(ret && GetLastError() == ERROR_SUCCESS, "InternetQueryOption failed: %d\n", GetLastError()); + + ok(size == size2, "expected same size\n"); + ok(!strcmp(certstr1, certstr2), "expected same string\n"); + InternetCloseHandle(req); InternetCloseHandle(con); InternetCloseHandle(ses); @@ -7517,6 +7608,37 @@ static void test_concurrent_header_access(void) CloseHandle( wait ); } +static void test_cert_string(void) +{ + HINTERNET ses, con, req; + char actual[512]; + DWORD size; + BOOL res; + + ses = InternetOpenA( "winetest", 0, NULL, NULL, 0 ); + ok( ses != NULL, "InternetOpenA failed\n" ); + + con = InternetConnectA( ses, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, + INTERNET_SERVICE_HTTP, 0, 0 ); + ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); + + req = HttpOpenRequestA( con, NULL, "/", NULL, NULL, NULL, 0, 0 ); + ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); + + size = sizeof(actual); + SetLastError( 0xdeadbeef ); + memset( actual, 0x55, sizeof(actual) ); + res = InternetQueryOptionA( req, INTERNET_OPTION_SECURITY_CERTIFICATE, actual, &size ); + ok( !res && GetLastError() == ERROR_INTERNET_INVALID_OPERATION, + "InternetQueryOption failed: %u\n", GetLastError() ); + ok( size == 0, "unexpected size: %u\n", size ); + ok( actual[0] == 0x55, "unexpected byte: %02x\n", actual[0] ); + + InternetCloseHandle( req ); + InternetCloseHandle( con ); + InternetCloseHandle( ses ); +} + START_TEST(http) { HMODULE hdll; @@ -7566,5 +7688,6 @@ START_TEST(http) test_connection_failure(); test_default_service_port(); test_concurrent_header_access(); + test_cert_string(); free_events(); } diff --git a/dlls/wininet/wininet.rc b/dlls/wininet/wininet.rc index b6e35629ca..5bd5b48ccc 100644 --- a/dlls/wininet/wininet.rc +++ b/dlls/wininet/wininet.rc @@ -29,6 +29,17 @@ STRINGTABLE IDS_CERT_DATE_INVALID "The date on the certificate is invalid." IDS_CERT_CN_INVALID "The name on the certificate does not match the site." IDS_CERT_ERRORS "There is at least one unspecified security problem with this certificate." + + IDS_CERT_FORMAT "Subject:\015\n%s\015\n" \ + "Issuer:\015\n%s\015\n" \ + "Effective Date:\t%s %s\015\n" \ + "Expiration Date:\t%s %s\015\n" \ + "Security Protocol:\t(null)\015\n" \ + "Signature Type:\t(null)\015\n" \ + "Encryption Type:\t(null)\015\n" \ + "Privacy Strength:\t%s (%u bits)" + IDS_CERT_HIGH "High" + IDS_CERT_LOW "Low" } IDD_PROXYDLG DIALOG 36, 24, 220, 146 -- 2.25.1

4 4

[PATCH 2/2] xactengine3_7: Use CLSID defined from global header.
by Alistair Leslie-Hughes 05 Aug '20

05 Aug '20

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/xactengine3_7/Makefile.in | 1 + dlls/xactengine3_7/xact_dll.c | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/xactengine3_7/Makefile.in b/dlls/xactengine3_7/Makefile.in index 6fce27d1628..6d486171622 100644 --- a/dlls/xactengine3_7/Makefile.in +++ b/dlls/xactengine3_7/Makefile.in @@ -1,5 +1,6 @@ MODULE = xactengine3_7.dll IMPORTS = ole32 uuid +EXTRADEFS = -DXACT3_VER=0x0307 EXTRALIBS = $(FAUDIO_LIBS) EXTRAINCL = $(FAUDIO_CFLAGS) diff --git a/dlls/xactengine3_7/xact_dll.c b/dlls/xactengine3_7/xact_dll.c index 69570e8ceff..2a55b49de25 100644 --- a/dlls/xactengine3_7/xact_dll.c +++ b/dlls/xactengine3_7/xact_dll.c @@ -27,7 +27,6 @@ #include "initguid.h" #include "xact3.h" #include "rpcproxy.h" -#include "xact_classes.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(xact3); @@ -511,7 +510,7 @@ HRESULT WINAPI DllCanUnloadNow(void) HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv) { - if (IsEqualGUID(rclsid, &CLSID_XACTEngine37)) + if (IsEqualGUID(rclsid, &CLSID_XACTEngine)) { TRACE("(%s, %s, %p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); return IClassFactory_QueryInterface(&XACTFactory, riid, ppv); -- 2.27.0

1 0

[PATCH] gdiplus: Avoid a few unnecessary calculations for arc2polybezier.
by Jeff Smith 05 Aug '20

05 Aug '20

Signed-off-by: Jeff Smith <whydoubt(a)gmail.com> --- 1. If width and height are equal, the 'unstretch' is not needed, though the unit conversion still is. 2. When the ratio between width and height is all that is needed, scaling them both equally is waste. 3. The start of a new partial is going to be the same as the end of the previous partial. dlls/gdiplus/gdiplus.c | 46 +++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/dlls/gdiplus/gdiplus.c b/dlls/gdiplus/gdiplus.c index d114ff797e..ee98d024f8 100644 --- a/dlls/gdiplus/gdiplus.c +++ b/dlls/gdiplus/gdiplus.c @@ -202,54 +202,54 @@ static void add_arc_part(GpPointF * pt, REAL x1, REAL y1, REAL x2, REAL y2, * adjusts the angles so that when we stretch the points they will end in the * right place. This is only complicated because atan and atan2 do not behave * conveniently. */ -static void unstretch_angle(REAL * angle, REAL rad_x, REAL rad_y) +static REAL unstretch_angle(REAL angle, REAL dia_x, REAL dia_y) { REAL stretched; INT revs_off; - *angle = deg2rad(*angle); + if(fabs(cos(angle)) < 0.00001 || fabs(sin(angle)) < 0.00001) + return angle; - if(fabs(cos(*angle)) < 0.00001 || fabs(sin(*angle)) < 0.00001) - return; - - stretched = gdiplus_atan2(sin(*angle) / fabs(rad_y), cos(*angle) / fabs(rad_x)); - revs_off = gdip_round(*angle / (2.0 * M_PI)) - gdip_round(stretched / (2.0 * M_PI)); + stretched = gdiplus_atan2(sin(angle) / fabs(dia_y), cos(angle) / fabs(dia_x)); + revs_off = gdip_round(angle / (2.0 * M_PI)) - gdip_round(stretched / (2.0 * M_PI)); stretched += ((REAL)revs_off) * M_PI * 2.0; - *angle = stretched; + return stretched; } /* Stores the bezier points that correspond to the arc in points. If points is * null, just return the number of points needed to represent the arc. */ -INT arc2polybezier(GpPointF * points, REAL x1, REAL y1, REAL x2, REAL y2, - REAL startAngle, REAL sweepAngle) +INT arc2polybezier(GpPointF * points, REAL left, REAL top, REAL width, REAL height, + REAL start_angle, REAL sweep_angle) { INT i; - REAL end_angle, start_angle, endAngle; + REAL partial_end_angle, end_angle; - endAngle = startAngle + sweepAngle; - unstretch_angle(&startAngle, x2 / 2.0, y2 / 2.0); - unstretch_angle(&endAngle, x2 / 2.0, y2 / 2.0); + end_angle = deg2rad(start_angle + sweep_angle); + start_angle = deg2rad(start_angle); - /* start_angle and end_angle are the iterative variables */ - start_angle = startAngle; + if (width != height) + { + start_angle = unstretch_angle(start_angle, width, height); + end_angle = unstretch_angle(end_angle, width, height); + } for(i = 0; i < MAX_ARC_PTS - 1; i += 3){ /* check if we've overshot the end angle */ - if( sweepAngle > 0.0 ) + if( sweep_angle > 0.0 ) { - if (start_angle >= endAngle) break; - end_angle = min(start_angle + M_PI_2, endAngle); + if (start_angle >= end_angle) break; + partial_end_angle = min(start_angle + M_PI_2, end_angle); } else { - if (start_angle <= endAngle) break; - end_angle = max(start_angle - M_PI_2, endAngle); + if (start_angle <= end_angle) break; + partial_end_angle = max(start_angle - M_PI_2, end_angle); } if (points) - add_arc_part(&points[i], x1, y1, x2, y2, start_angle, end_angle, i == 0); + add_arc_part(&points[i], left, top, width, height, start_angle, partial_end_angle, i == 0); - start_angle += M_PI_2 * (sweepAngle < 0.0 ? -1.0 : 1.0); + start_angle = partial_end_angle; } if (i == 0) return 0; -- 2.23.0

2 1

[PATCH v2] dmime: Parse TimeSig track data.
by Alistair Leslie-Hughes 04 Aug '20

04 Aug '20

The tims data actually has a DWORD (size) before the structure. Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/dmime/timesigtrack.c | 61 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/dlls/dmime/timesigtrack.c b/dlls/dmime/timesigtrack.c index 697b3e3593b..f61e87806e9 100644 --- a/dlls/dmime/timesigtrack.c +++ b/dlls/dmime/timesigtrack.c @@ -37,6 +37,11 @@ static inline IDirectMusicTimeSigTrack *impl_from_IDirectMusicTrack(IDirectMusic return CONTAINING_RECORD(iface, IDirectMusicTimeSigTrack, IDirectMusicTrack_iface); } +static inline IDirectMusicTimeSigTrack *impl_from_IPersistStream(IPersistStream *iface) +{ + return CONTAINING_RECORD(iface, IDirectMusicTimeSigTrack, dmobj.IPersistStream_iface); +} + static HRESULT WINAPI IDirectMusicTrackImpl_QueryInterface(IDirectMusicTrack *iface, REFIID riid, void **ret_iface) { @@ -207,10 +212,62 @@ static const IDirectMusicTrackVtbl dmtack_vtbl = { IDirectMusicTrackImpl_Clone }; +struct timesig_item +{ + DWORD size; + DMUS_IO_TIMESIGNATURE_ITEM timesig; +}; + +static HRESULT parse_timetrack_list(IDirectMusicTimeSigTrack *This, IStream *stream, + struct chunk_entry *timesig) +{ + HRESULT hr; + struct chunk_entry chunk = {.parent = timesig}; + struct timesig_item item; + + TRACE("Parsing segment form in %p: %s\n", stream, debugstr_chunk(timesig)); + + while ((hr = stream_next_chunk(stream, &chunk)) == S_OK) { + if (chunk.id != DMUS_FOURCC_TIMESIGNATURE_TRACK) + return DMUS_E_UNSUPPORTED_STREAM; + + if (FAILED(hr = stream_chunk_get_data(stream, &chunk, &item, sizeof(item)))) { + WARN("Failed to read data of %s\n", debugstr_chunk(&chunk)); + return hr; + } + + TRACE(" Size %d\n", item.size); + + TRACE("Found DMUS_IO_TIMESIGNATURE_ITEM\n"); + TRACE(" - lTime %d\n", item.timesig.lTime); + TRACE(" - bBeatsPerMeasure %d\n", item.timesig.bBeatsPerMeasure); + TRACE(" - bBeat %d\n", item.timesig.bBeat); + TRACE(" - wGridsPerBeat %d\n", item.timesig.wGridsPerBeat); + } + + return SUCCEEDED(hr) ? S_OK : hr; +} + static HRESULT WINAPI time_IPersistStream_Load(IPersistStream *iface, IStream *stream) { - FIXME(": Loading not implemented yet\n"); - return S_OK; + IDirectMusicTimeSigTrack *This = impl_from_IPersistStream(iface); + HRESULT hr; + struct chunk_entry chunk = {0}; + + TRACE("%p, %p\n", This, stream); + + if (!stream) + return E_POINTER; + + if ((hr = stream_get_chunk(stream, &chunk) != S_OK)) + return hr; + + if (chunk.id == FOURCC_LIST && chunk.type == DMUS_FOURCC_TIMESIGTRACK_LIST) + hr = parse_timetrack_list(This, stream, &chunk); + else + hr = DMUS_E_UNSUPPORTED_STREAM; + + return hr; } static const IPersistStreamVtbl persiststream_vtbl = { -- 2.27.0

2 2

[PATCH 2/2] dmime: Simplify loading/storing of the Tempo Track data
by Michael Stefaniuc 04 Aug '20

04 Aug '20

Fixes loading more than one tempo items. Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- Turns out the pattern of storing an array in a chunk as DWORD - size of element elements[] - array of elements is pretty common. 10 IDirectMusicTrack implementations have it, some of them in multiple chunk types. dlls/dmime/dmobject.c | 45 ++++++++++++++++++ dlls/dmime/dmobject.h | 2 + dlls/dmime/tempotrack.c | 102 +++++++++++++++------------------------- 3 files changed, 85 insertions(+), 64 deletions(-) diff --git a/dlls/dmime/dmobject.c b/dlls/dmime/dmobject.c index 0ef007530fd..e6a1ce906a7 100644 --- a/dlls/dmime/dmobject.c +++ b/dlls/dmime/dmobject.c @@ -28,6 +28,7 @@ #include "dmusics.h" #include "dmobject.h" #include "wine/debug.h" +#include "wine/heap.h" WINE_DEFAULT_DEBUG_CHANNEL(dmobj); WINE_DECLARE_DEBUG_CHANNEL(dmfile); @@ -371,6 +372,50 @@ HRESULT stream_next_chunk(IStream *stream, struct chunk_entry *chunk) return stream_get_chunk(stream, chunk); } +/* Reads chunk data of the form: + DWORD - size of array element + element[] - Array of elements + The caller needs to heap_free() the array. +*/ +HRESULT stream_chunk_get_array(IStream *stream, const struct chunk_entry *chunk, void **array, + unsigned int *count, DWORD elem_size) +{ + DWORD size; + HRESULT hr; + + *array = NULL; + *count = 0; + + if (chunk->size < sizeof(DWORD)) { + WARN_(dmfile)("%s: Too short to read element size\n", debugstr_chunk(chunk)); + return E_FAIL; + } + if (FAILED(hr = stream_read(stream, &size, sizeof(DWORD)))) + return hr; + if (size != elem_size) { + WARN_(dmfile)("%s: Array element size mismatch: got %u, expected %u\n", + debugstr_chunk(chunk), size, elem_size); + return DMUS_E_UNSUPPORTED_STREAM; + } + + *count = (chunk->size - sizeof(DWORD)) / elem_size; + size = *count * elem_size; + if (!(*array = heap_alloc(size))) + return E_OUTOFMEMORY; + if (FAILED(hr = stream_read(stream, *array, size))) { + heap_free(*array); + *array = NULL; + return hr; + } + + if (chunk->size > size + sizeof(DWORD)) { + WARN_(dmfile)("%s: Extraneous data at end of array\n", debugstr_chunk(chunk)); + stream_skip_chunk(stream, chunk); + return S_FALSE; + } + return S_OK; +} + HRESULT stream_chunk_get_data(IStream *stream, const struct chunk_entry *chunk, void *data, ULONG size) { diff --git a/dlls/dmime/dmobject.h b/dlls/dmime/dmobject.h index a1729c83232..afe721dc824 100644 --- a/dlls/dmime/dmobject.h +++ b/dlls/dmime/dmobject.h @@ -35,6 +35,8 @@ HRESULT stream_get_chunk(IStream *stream, struct chunk_entry *chunk) DECLSPEC_HI HRESULT stream_next_chunk(IStream *stream, struct chunk_entry *chunk) DECLSPEC_HIDDEN; HRESULT stream_skip_chunk(IStream *stream, const struct chunk_entry *chunk) DECLSPEC_HIDDEN; +HRESULT stream_chunk_get_array(IStream *stream, const struct chunk_entry *chunk, void **array, + unsigned int *count, DWORD elem_size) DECLSPEC_HIDDEN; HRESULT stream_chunk_get_data(IStream *stream, const struct chunk_entry *chunk, void *data, ULONG size) DECLSPEC_HIDDEN; HRESULT stream_chunk_get_wstr(IStream *stream, const struct chunk_entry *chunk, WCHAR *str, diff --git a/dlls/dmime/tempotrack.c b/dlls/dmime/tempotrack.c index 94e4430b7f9..9d25ccc298c 100644 --- a/dlls/dmime/tempotrack.c +++ b/dlls/dmime/tempotrack.c @@ -29,11 +29,13 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile); /***************************************************************************** * IDirectMusicTempoTrack implementation */ + typedef struct IDirectMusicTempoTrack { IDirectMusicTrack8 IDirectMusicTrack8_iface; struct dmobject dmobj; /* IPersistStream only */ LONG ref; - struct list Items; + DMUS_IO_TEMPO_ITEM *items; + unsigned int count; } IDirectMusicTempoTrack; /* IDirectMusicTempoTrack IDirectMusicTrack8 part: */ @@ -83,16 +85,7 @@ static ULONG WINAPI tempo_track_Release(IDirectMusicTrack8 *iface) TRACE("(%p) ref=%d\n", This, ref); if (!ref) { - struct list *cursor, *cursor2; - DMUS_PRIVATE_TEMPO_ITEM *item; - - LIST_FOR_EACH_SAFE(cursor, cursor2, &This->Items) { - item = LIST_ENTRY(cursor, DMUS_PRIVATE_TEMPO_ITEM, entry); - list_remove(cursor); - - heap_free(item); - } - + heap_free(This->items); heap_free(This); DMIME_UnlockModule(); } @@ -157,8 +150,8 @@ static HRESULT WINAPI tempo_track_GetParam(IDirectMusicTrack8 *iface, REFGUID ty MUSIC_TIME *next, void *param) { IDirectMusicTempoTrack *This = impl_from_IDirectMusicTrack8(iface); - DMUS_PRIVATE_TEMPO_ITEM *item = NULL; DMUS_TEMPO_PARAM *prm = param; + unsigned int i; TRACE("(%p, %s, %d, %p, %p)\n", This, debugstr_dmguid(type), time, next, param); @@ -174,15 +167,15 @@ static HRESULT WINAPI tempo_track_GetParam(IDirectMusicTrack8 *iface, REFGUID ty prm->mtTime = 0; prm->dblTempo = 0.123456; - LIST_FOR_EACH_ENTRY(item, &This->Items, DMUS_PRIVATE_TEMPO_ITEM, entry) { - if (item->item.lTime <= time) { - MUSIC_TIME ofs = item->item.lTime - time; + for (i = 0; i < This->count; i++) { + if (This->items[i].lTime <= time) { + MUSIC_TIME ofs = This->items[i].lTime - time; if (ofs > prm->mtTime) { prm->mtTime = ofs; - prm->dblTempo = item->item.dblTempo; + prm->dblTempo = This->items[i].dblTempo; } - if (next && item->item.lTime > time && item->item.lTime < *next) - *next = item->item.lTime; + if (next && This->items[i].lTime > time && This->items[i].lTime < *next) + *next = This->items[i].lTime; } } @@ -334,53 +327,35 @@ static inline IDirectMusicTempoTrack *impl_from_IPersistStream(IPersistStream *i return CONTAINING_RECORD(iface, IDirectMusicTempoTrack, dmobj.IPersistStream_iface); } -static HRESULT WINAPI tempo_IPersistStream_Load(IPersistStream *iface, IStream *pStm) +static HRESULT WINAPI tempo_IPersistStream_Load(IPersistStream *iface, IStream *stream) { - IDirectMusicTempoTrack *This = impl_from_IPersistStream(iface); - DMUS_PRIVATE_CHUNK Chunk; - DWORD StreamSize, StreamCount; - LARGE_INTEGER liMove; - DMUS_IO_TEMPO_ITEM item; - LPDMUS_PRIVATE_TEMPO_ITEM pNewItem = NULL; - DWORD nItem = 0; - FIXME("(%p, %p): Loading not fully implemented yet\n", This, pStm); - - IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); - TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); - switch (Chunk.fccID) { - case DMUS_FOURCC_TEMPO_TRACK: { - TRACE_(dmfile)(": Tempo track\n"); - IStream_Read (pStm, &StreamSize, sizeof(DWORD), NULL); - StreamSize -= sizeof(DWORD); - StreamCount = 0; - TRACE_(dmfile)(" - sizeof(DMUS_IO_TEMPO_ITEM): %u (chunkSize = %u)\n", StreamSize, Chunk.dwSize); - do { - IStream_Read (pStm, &item, sizeof(item), NULL); - ++nItem; - TRACE_(dmfile)("DMUS_IO_TEMPO_ITEM #%d\n", nItem); - TRACE_(dmfile)(" - lTime = %u\n", item.lTime); - TRACE_(dmfile)(" - dblTempo = %g\n", item.dblTempo); - pNewItem = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_TEMPO_ITEM)); - if (NULL == pNewItem) - return E_OUTOFMEMORY; - - pNewItem->item = item; - list_add_tail (&This->Items, &pNewItem->entry); - pNewItem = NULL; - StreamCount += sizeof(item); - TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize); - } while (StreamCount < StreamSize); - break; - } - default: { - TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); - liMove.QuadPart = Chunk.dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - return E_FAIL; - } - } + IDirectMusicTempoTrack *This = impl_from_IPersistStream(iface); + struct chunk_entry chunk = {0}; + unsigned int i; + HRESULT hr; - return S_OK; + TRACE("%p, %p\n", This, stream); + + if (!stream) + return E_POINTER; + + if ((hr = stream_get_chunk(stream, &chunk) != S_OK)) + return hr; + if (chunk.id != DMUS_FOURCC_TEMPO_TRACK) + return DMUS_E_UNSUPPORTED_STREAM; + + hr = stream_chunk_get_array(stream, &chunk, (void **)&This->items, &This->count, + sizeof(DMUS_IO_TEMPO_ITEM)); + if (FAILED(hr)) + return hr; + + for (i = 0; i < This->count; i++) { + TRACE_(dmfile)("DMUS_IO_TEMPO_ITEM #%u\n", i); + TRACE_(dmfile)(" - lTime = %u\n", This->items[i].lTime); + TRACE_(dmfile)(" - dblTempo = %g\n", This->items[i].dblTempo); + } + + return S_OK; } static const IPersistStreamVtbl persiststream_vtbl = { @@ -410,7 +385,6 @@ HRESULT WINAPI create_dmtempotrack(REFIID lpcGUID, void **ppobj) dmobject_init(&track->dmobj, &CLSID_DirectMusicTempoTrack, (IUnknown *)&track->IDirectMusicTrack8_iface); track->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl; - list_init(&track->Items); DMIME_LockModule(); hr = IDirectMusicTrack8_QueryInterface(&track->IDirectMusicTrack8_iface, lpcGUID, ppobj); -- 2.26.2

1 0