widl: Use the correct type for non-encapsulated union discriminants.

widl: Output more correct /robust flags.
widl: Add /robust flags in correlation descriptors.
2025-03-07 03:53:26 +01:00 · 2024-04-02 23:30:10 +02:00 · 2024-04-02 23:30:10 +02:00 · 2024-04-02 23:30:10 +02:00 · 2024-04-02 23:30:03 +02:00 · 2024-04-02 12:17:26 +02:00
4757 changed files with 552281 additions and 254902 deletions
--- a/.mailmap
+++ b/.mailmap
@ -18,7 +18,7 @@ Charles Davis <cdavis@codeweavers.com>
 Charles Davis <cdavis5x@gmail.com>
 Christopher Gautier <krys@via.ecp.fr>
 David A. Cuthbert <dacut@ece.cmu.edu>
-David Heidelberger <david@ixit.cz>
+David Heidelberg <david@ixit.cz>
 Dennis Björklund <db@zigo.dhs.org>
 Dennis Björklund <dennisb@cs.chalmers.se>
 Dimitrie O. Paun <dimi@bigfoot.com>
@ -30,6 +30,7 @@ Erich Hoover <erich.e.hoover@wine-staging.com>
 Erwin Wolff <erwinwolffnl@microformatica.com>
 Esme Povirk <vincent@codeweavers.com>
 Evgeny Putin <evcalipt@etersoft.ru>
+Fan WenJie <fanwj@mail.ustc.edu.cn>
 Fatih Aşıcı <fasici@linux-sevenler.org>
 Fernando Martins <fernando@cmartins.nl>
 François Gouget <fgouget@codeweavers.com>
@ -155,6 +156,7 @@ William Poetra Yoga Hadisoesen <williampoetra@yahoo.com>
 Won Kyu Park <wkpark@kldp.org>
 Yuri Kozlov <yuriy.kozlov@gmail.com>
 Zachary Brown <zac@zacbrown.org>
+Zebediah Figura <zfigura@codeweavers.com>
 Zoltan Nagy <nagyzoli@drotposta.hu>
 unidentified <9700584@cs.stadia.fi>
 unidentified <develop@stueben.com>
--- a/359
+++ b/359
@ -1,359 +0,0 @@
-The Wine development release 8.3 is now available.
-
-What's new in this release:
-  - Support for the Low Fragmentation Heap.
-  - Smard card support using PCSC-Lite.
-  - Bundled Zydis library for more correct disassembly.
-  - Various bug fixes.
-
-The source is available at:
-
-  https://dl.winehq.org/wine/source/8.x/wine-8.3.tar.xz
-
-Binary packages for various distributions will be available from:
-
-  https://www.winehq.org/download
-
-You will find documentation on https://www.winehq.org/documentation
-
-You can also get the current source directly from the git
-repository. Check https://www.winehq.org/git for details.
-
-Wine is available thanks to the work of many people. See the file
-AUTHORS in the distribution for the complete list.
-
----------------------------------------------------------------
-
-Bugs fixed in 8.3 (total 29):
-
- - #24256  3D Sexvilla 2: extremely long loading times
- - #34011  Path of Exile stutters constantly
- - #37146  Untis 2015 (.NET 4.0 app) crashes on startup with Wine-Mono
- - #37495  Multiple PC/SC applications need winscard.SCardEstablishContext implementation (AusweisApp2 1.x german identity card app, SmartCard test apps, Seneka EBDYS client, Aruba Key)
- - #39113  Multiple PC/SC applications need winscard.SCardListReaders implementation (Aruba key, SmartCard test apps)
- - #43224  Freelist scan can result in O(n) time when allocating
- - #45756  Button not clickable when dpi setting changed in Office 2007 Installer
- - #49113  Wine heap performs badly when multiple threads are concurrently allocating or freeing memory
- - #51259  6.0.1 Introduces error causing Wavelab to close when loading presets
- - #52506  Setup of game "What's the Secret?" fails to create icon
- - #53094  ntdll:rtlstr test crashes on win32 arch with hi-IN locale
- - #53176  KeePassXC needs Windows.Security.Credentials.KeyCredentialManager (UWP)
- - #53504  Sacred:unhandled exception in Wine 7.14
- - #53728  Escape from Tarkov needs DisplayConfigGetDeviceInfo(DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME) implementation
- - #54112  rouvy : fails to update with server, unimplemented function bthprops.cpl.BluetoothRegisterForAuthenticationEx
- - #54149  shlwapi:ordinal - test_SHFormatDateTimeA() fails on the mixed locales configuration
- - #54338  Swift crashes due to unimplemented api-ms-win-core-realtime-l1-1-1.dll.QueryUnbiasedInterruptTimePrecise function
- - #54432  Missing ntdll.RtlAddressInSectionTable() implementation causes all GraalVM Native Image exes to crash on load
- - #54475  Hardwar UIM6.0 crashes in 8.0, doesn't in 6.0.3
- - #54534  dbghelp:dbghelp - The test_loaded_modules() enumeration fails on Windows 10 1607
- - #54559  riched20:editor - test_EM_GETSELTEXT() fails in the Hindi locale on Windows
- - #54562  The 64-bit oleaut32:usrmarshal crashes in Wine
- - #54564  Rich Edit crashes when Ctrl+Right is pressed at past the final paragraph
- - #54565  riched20:richole - subtest_InsertObject() fails in the Hindi locale on Windows
- - #54570  Saints Row: The Third heavy rain causes heavy fps reductions
- - #54581  SpeedCommander 20 installer crashes on unimplemented function SHELL32.dll.Shell_GetCachedImageIndexW
- - #54582  kernel32:locale - test_NLSVersion() fails on Windows 10 22H2
- - #54583  kernel32:locale - The non-breaking space GetNumberFormatEx() test fails on Windows 11
- - #54584  kernel32:locale - The NtGetNlsSectionPtr() test fails on Windows 11
-
----------------------------------------------------------------
-
-Changes since 8.2:
-
-Adrian Thiele (2):
-      mfreadwrite/tests: Check refcount of device manager after release.
-      mfreadwrite/reader: Release device manager in source_reader_release.
-
-Akihiro Sagawa (1):
-      msado15: Free recordset filter on close.
-
-Alex Henrie (7):
-      include: Annotate CommandLineToArgvW with __WINE_DEALLOC.
-      shell32: Add support for Program Manager icons with arguments.
-      dsound: Use CRT functions for memory allocation.
-      winex11: Use RTL_CONSTANT_STRING instead of reimplementing it.
-      winex11: Avoid calling RtlInitUnicodeString on a static constant.
-      server: Annotate allocation functions with __WINE_(ALLOC_SIZE|DEALLOC|MALLOC).
-      ntoskrnl: Add ExGetPreviousMode and test.
-
-Alexandre Julliard (33):
-      conhost: Use standard va_list instead of __ms_va_list.
-      notepad: Use standard va_list instead of __ms_va_list.
-      oleview: Use standard va_list instead of __ms_va_list.
-      start: Use standard va_list instead of __ms_va_list.
-      taskmgr: Use standard va_list instead of __ms_va_list.
-      winefile: Use standard va_list instead of __ms_va_list.
-      include: Move __builtin_ms_va_list definitions to vadefs.h.
-      ntdll: Pass the NtCreateNamedPipeFile disposition to the server.
-      ntdll: Return the correct IOSB information when creating a named pipe.
-      kernelbase: Set ERROR_ALREADY_EXISTS for existing pipe in CreateNamedPipeW().
-      makedep: Don't add dependencies for tests of disabled dlls.
-      kernel32/tests: Add a missing dependency comment.
-      ntdll: Stop loading libwine.so.
-      libwine: Remove obsolete library.
-      ntdll: Build an initial WoW context on ARM64.
-      ntdll: Implement getting/setting the WoW context on ARM64.
-      ntdll: Mark the Wow64 TLS slots as reserved.
-      makedep: Remove support for building shared libraries.
-      winegcc: Stop using the deprecated prelink tool.
-      winebuild: Only allow the stdcall calling convention for system calls.
-      libs: Import the Zydis library version 4.0.0.
-      winedbg: Use the Zydis library for disassembly.
-      ntdll: Update the IOSB status in NtCreateNamedPipeFile().
-      ntdll: Skip dependency only for the actually loaded ntdll and kernel32, instead of matching by name.
-      ntdll: Also check for data execution on x86-64.
-      wow64: Call the 32-bit KiRaiseUserExceptionDispatcher for invalid handle exceptions.
-      makedep: Store the list of .ok files per-architecture.
-      ntdll: Implement RtlAddProcessTrustLabelAce().
-      server: Fix another buffer overflow compiler warning.
-      wine.inf: Remove redundant platform-specific sections.
-      wine.inf: Set Program Files variables separately for all WoW platforms.
-      wine.inf: Add keys for the platform-specific Wow64 backend.
-      wow64: Get the backend dll name from the registry.
-
-Alexandros Frantzis (2):
-      gdi32: Track ticks since draw start per window_surface.
-      win32u: Reset draw_start_ticks for new window_surface.
-
-Alistair Leslie-Hughes (4):
-      msado15: Semi-stub _Recordset get/put Filter.
-      msado15: Field ActualSize return a default size.
-      msado15: Support "Optimize" in Properties get_Item.
-      include: Add DBCOLUMNFLAGS_ enums values.
-
-Connor McAdams (14):
-      uiautomationcore: Register all UI Automation typelibs.
-      uiautomationcore: Add stub IUIAutomation implementation.
-      uiautomationcore: Implement IUIAutomation::ElementFromHandle.
-      uiautomationcore: Implement IUIAutomationElement::GetCurrentPropertyValueEx.
-      uiautomationcore: Implement UiaLookupId for AutomationIdentifierType_ControlType GUIDs.
-      uiautomationcore: Implement IUIAutomationElement::get_CurrentControlType.
-      uiautomationcore: Implement IUIAutomationElement::get_CurrentName.
-      uiautomationcore: Implement IUIAutomationElement::get_CurrentBoundingRectangle.
-      uiautomationcore/tests: Fix UiaHUiaNodeFromVariant tests on Windows 11.
-      uiautomationcore/tests: Fix UiaNodeFromHandle tests on Windows 11.
-      uiautomationcore: Implement IUIAutomation::IntSafeArrayToNativeArray.
-      uiautomationcore: Implement IUIAutomation::IntNativeArrayToSafeArray.
-      uiautomationcore: Implement IUIAutomation reserved value retrieval methods.
-      uiautomationcore: Implement IUIAutomation::CheckNotSupported.
-
-David Gow (1):
-      dxgi: Don't warn on DXGI_ALPHA_MODE_UNSPECIFIED with wined3d.
-
-Eric Pouech (11):
-      dbghelp/tests: Test that overlapped module is really unloaded.
-      include: Ensure that SymRefreshModuleList() is properly defined.
-      kernel32/tests: Don't let debugger tests fail on a 64bit only config.
-      dbghelp/tests: Fix failure on Win10 1607.
-      kernel32/tests: Fix debugger.c:test_kill_on_exit().
-      dbghelp/tests: Add wrapper for EnumerateLoadedModulesW64().
-      dbghelp/tests: Adapt test_modules_overlap() for Windows 11.
-      dbghelp/tests: Introduce ends_withW helper.
-      dbghelp/tests: Only retrieve the system directories once.
-      dbghelp/tests: Introduce get_machine_bitness() helper.
-      dbghelp/tests: Fix tests for process count in wow64.
-
-Etaash Mathamsetty (1):
-      ntoskrnl.exe/tests: Add Driver Object Extension Tests.
-
-Florian Will (2):
-      gdiplus/tests: Test for GdipPrivateAddFontFile() sharing violation.
-      gdiplus: Use FILE_SHARE_READ in GdipPrivateAddFontFile().
-
-François Gouget (20):
-      jsproxy/tests: InternetInitializeAutoProxyDll() is no longer supported on Windows 11.
-      jsproxy/tests: Add more tests for InternetGetProxyInfo()'s length parameter.
-      gdi32/tests: Mark a couple other D3DKMTCheckOcclusion() tests as flaky.
-      vbscript/tests: Fix the testChrError() tests.
-      winmm/tests: Ignore spurious WM_DWMCOLORIZATIONCOLORCHANGED messages.
-      mscoree/tests: Trace the error when a Windows API fails.
-      kernel32/tests: Fix the NLSVersion test on Windows 10 22H2.
-      kernel32/tests: Fix the NtGetNlsSectionPtr() test on Windows 11.
-      kernel32/tests: Fix the French GetNumberFormatEx() test on Windows 11.
-      gdi32/tests: Simplify setting up the non uniform gamma ramps.
-      gdi32/tests: Make the gamma ramp failures more unique.
-      gdi32/tests: Fix the SetDeviceGammaRamp() tests on Windows 10 1909.
-      mscoree/tests: Trace the GetExitCodeProcess() error before it gets lost.
-      ntdll/tests: Minimize the stack size for test_tp_multi_wait().
-      riched32/tests: EM_GETSELTEXT's wparam is not used and should be 0.
-      riched20/tests: EM_GETSELTEXT's wparam is not used and should be 0.
-      riched20/tests: Fix the EM_GETSELTEXT tests in Hindi on Windows.
-      mmdevapi/tests: WoW64 processes can read the properties from the registry.
-      shlwapi/tests: Fix the date formatting tests when the locale does not match the code page.
-      shlwapi/tests: Make sure to test the formatting of troublesome dates.
-
-Gabriel Ivăncescu (8):
-      mshtml: Use proper types for readystate_locked and readystate_pending.
-      mshtml: Free the task after the destructor.
-      mshtml: Pass optional args to XMLHttpRequest.open() correctly.
-      mshtml: Register all event handlers when creating the XMLHttpRequest.
-      mshtml: Track readyState in XHRs and report it manually.
-      mshtml: Add separate task list for tasks dispatching events.
-      mshtml: Implement synchronous XMLHttpRequest.
-      mshtml: Send all readystatechange events for synchronous XHRs in IE9 and below.
-
-Gijs Vermeulen (1):
-      shell32: Add Shell_GetCachedImageIndexA/W exports.
-
-Hans Leidekker (19):
-      include: Add missing smart card defines.
-      winscard: Implement SCardEstablish/ReleaseContext() on top of libpcsclite.
-      winscard: Implement SCardIsValidContext().
-      winscard: Implement SCardGetStatusChangeA/W().
-      winscard: Implement SCardCancel().
-      winscard: Implement SCardListReadersA/W().
-      winscard: Implement SCardListReaderGroupsA/W().
-      winscard: Implement SCardConnectA/W().
-      winscard: Implement SCardStatusA/W().
-      winscard: Implement SCardRe/Disconnect().
-      winscard: Implement SCardBegin/EndTransaction().
-      winscard: Implement SCardTransmit().
-      winscard: Implement SCardControl().
-      winscard: Implement SCardGet/SetAttrib().
-      winscard: Implement SCardFreeMemory().
-      winscard: Use string conversion helpers in SCardAddReaderToGroupA().
-      winscard: Improve traces.
-      winscard: Add wow64 thunks.
-      winscard/tests: Initial tests.
-
-Henry Goffin (1):
-      win32u: Invalidate all cached keys after input.
-
-Huw D. M. Davies (2):
-      winemac: Fix return type of ProcessEvents().
-      maintainers: Add myself to the Audio I/O section.
-
-Illia Polishchuk (2):
-      d3d9/tests: Add test for non-indexed instancing drawing.
-      d3d9: Always draw only a single instance for non-indexed draws.
-
-Ivan Chikish (1):
-      gdi32/tests: Check last error on ' '.
-
-Jinoh Kang (2):
-      riched20/tests: Test for word movement across paragraph boundary.
-      riched20: Don't set para unless committing cursor move in ME_MoveCursorWords.
-
-Marcus Meissner (1):
-      user32/tests: Fix size passed to ToUnicode.
-
-Max Figura (15):
-      wined3d: Move the WINED3D_RS_ROP2 stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_PLANEMASK stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_LASTPIXEL stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_ZVISIBLE stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_SUBPIXEL stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_SUBPIXELX stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_STIPPLEDALPHA stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_STIPPLEENABLE stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_MIPMAPLODBIAS stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_ANISOTROPY stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_FLUSHBATCH stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_TRANSLUCENTSORTINDEPENDENT stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_WRAP15 stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_WRAP14 stub to wined3d_device_apply_stateblock.
-      wined3d: Move the WINED3D_RS_WRAP13 stub to wined3d_device_apply_stateblock.
-
-Mohamad Al-Jaf (15):
-      bthprops.cpl: Move implementations to bluetoothapis and import them.
-      include: Add BluetoothRegisterForAuthenticationEx prototype.
-      bluetoothapis: Add BluetoothRegisterForAuthenticationEx stub.
-      bluetoothapis: Add BluetoothUnregisterAuthentication stub.
-      include: Fix BluetoothRegisterForAuthentication prototype.
-      include: Add windows.security.credentials.idl file.
-      cryptowinrt/tests: Add ICryptographicBufferStatics interface test.
-      cryptowinrt: Add private.h file.
-      cryptowinrt: Stub IKeyCredentialManagerStatics interface.
-      cryptowinrt: Import IAsyncOperation from windows.gaming.input.
-      cryptowinrt: Implement IKeyCredentialManagerStatics::IsSupportedAsync().
-      cryptowinrt/tests: Add IKeyCredentialManagerStatics::IsSupportedAsync() tests.
-      widl: Use "i4" / "u4" for LONG parameterized type signature.
-      widl: Use "i2" / "u2" for INT16 parameterized type signature.
-      include: Add more Windows.Foundation.Numerics structs.
-
-Paul Gofman (3):
-      server: Retry socket connection on ECONNABORTED error.
-      server: Set TCP SYN count on sockets.
-      win32u: Expose and use ProcessEvents from drivers instead of MsgWaitForMultipleObjectsEx.
-
-Philip Gruebele (1):
-      dwrite: Pass correct font key when adding glyph to cache.
-
-Piotr Caban (4):
-      winspool: Fix FILE: output handling in StartDocDlgW.
-      wineps: Remove no longer used output parameter handling from PSDRV_CreateDC.
-      localspl: Ignore an empty output string.
-      windowscodecs: Don't reorder gif extension blocks in GetReaderByIndex.
-
-Rémi Bernon (23):
-      ntdll: Fix HeapWalk with empty uncommitted consecutive subheaps.
-      ntdll: Implement HeapCompatibilityInformation.
-      ntdll: Increase heap block tail_size capacity to 16 bits.
-      ntdll: Count allocations and automatically enable LFH.
-      ntdll: Split heap_resize_block into heap_resize_(block|large) helpers.
-      ntdll: Implement Low Fragmentation Heap frontend.
-      ntdll: Use atomics and lock-free list for bin groups.
-      ntdll: Add a heap thread affinity and per-affinity bin group cache.
-      ntdll: Avoid shrinking large heap block to small block.
-      msvcr80/tests: Test _dupenv_s outcome with missing env var.
-      msvcr80/tests: Test _wdupenv_s outcome with missing env var.
-      msvcrt: Fix _dupenv_s behavior with missing env var.
-      msvcrt: Fix _wdupenv_s behavior with missing env var.
-      include: Allow overriding LANGID in module VERSIONINFO.
-      oleaut32/tests: Test VARIANT_UserUnmarshal allocation sizes.
-      oleaut32: Allocate a full pointer when unmarshalling byref arrays.
-      winex11: Assume that Xkb extension is available.
-      widl: Use "g16" for GUID parameterized type signature.
-      user32/tests: Test VK_MENU effect on ToUnicode.
-      win32u: Map VK_MENU / KBDALT in kbdus_tables pCharModifiers.
-      win32u: Return the current display mode depth with nulldrv.
-      explorer: Use GUID_NULL display device GUID for nulldrv.
-      win32u: Check GUID_NULL display device if desktop atom is missing.
-
-Serkan Önder (1):
-      po: Update Turkish translation.
-
-Sven Baars (3):
-      bcrypt: Factor out wow64 padding conversion.
-      bcrypt: Add wow64 support for PSS padding.
-      bcrypt: Remove unused fields from struct key_asymmetric32.
-
-Tingzhong Luo (2):
-      evr: Fix crash when clearing input type for the mixer.
-      winspool: Check dmSize in IsValidDevmodeW().
-
-Torge Matthies (4):
-      kernelbase: Break out of inner for-loop early in find_substring.
-      kernelbase: Reuse the previous iteration's pos and sortkey state if possible in find_substring.
-      kernelbase: Fix WaitForThreadpoolIoCallbacks spec entry.
-      kernel32: Fix WaitForThreadpoolIoCallbacks spec entry.
-
-Zebediah Figura (16):
-      user32: Map DEV_BROADCAST_DEVICEINTERFACE to ANSI for registered device notifications.
-      ntoskrnl/tests: Expand tests for device and interface naming.
-      ntoskrnl: Preserve the device instance ID case in IoRegisterDeviceInterface().
-      Revert "ntoskrnl.exe: Enforce path case in WM_DEVICECHANGE notifications.".
-      wined3d: Require fragment shader image stores and atomics to create a feature level 11.0 device.
-      wined3d: Require gather offset support to create a feature level 11.0 device.
-      wined3d: Require shader clip distance support to create a feature level 10.0 device.
-      wined3d: Require shader cull distance support to create a feature level 10.0 device.
-      wined3d: Disable 64-bit integer support.
-      ddraw/tests: Test that surface properties are retained across SetSurfaceDesc() calls.
-      ddraw/tests: Add more tests for mipmap surface creation flags.
-      ddraw: Forbid DDSCAPS_COMPLEX without any caps that merit a complex surface.
-      ddraw: Forbid DDSD_MIPMAPCOUNT without DDSCAPS_COMPLEX.
-      ddraw: Remove the redundant "desc" parameter to ddraw_surface_create_wined3d_texture().
-      d3d8/tests: Do not check for WM_MOVE in sc_maximize_messages.
-      d3d9/tests: Restore the focus window before sending SC_MAXIMIZE to it.
-
-Zhiyi Zhang (4):
-      include: Add DirectComposition error codes.
-      include: Add dcomptypes.idl.
-      include: Add dcompanimation.idl.
-      include: Add dcomp.idl.
-
-Ziqing Hui (4):
-      mf/tests: Add missing \n.
-      mf/tests: Correctly initialize DMO media type.
-      mf/tests: Test ProcessInput and ProcessOutput for WMV decoder DMO.
-      mf/tests: Test output data for WMV decoder DMO.
--- a/ANNOUNCE.md
+++ b/ANNOUNCE.md
@ -0,0 +1,390 @@
+The Wine development release 9.5 is now available.
+
+What's new in this release:
+  - Initial SLTG-format typelib support in widl.
+  - Exception handling on ARM64EC.
+  - Improvements to Minidump support.
+  - Various bug fixes.
+
+The source is available at <https://dl.winehq.org/wine/source/9.x/wine-9.5.tar.xz>
+
+Binary packages for various distributions will be available
+from <https://www.winehq.org/download>
+
+You will find documentation on <https://www.winehq.org/documentation>
+
+Wine is available thanks to the work of many people.
+See the file [AUTHORS][1] for the complete list.
+
+[1]: https://gitlab.winehq.org/wine/wine/-/raw/wine-9.5/AUTHORS
+
+----------------------------------------------------------------
+
+### Bugs fixed in 9.5 (total 27):
+
+ - #25207  SHFileOperation does not create new directory on FO_MOVE
+ - #29523  CDBurnerXP hangs on right-clicking empty space in the file browser
+ - #40613  Multiple applications require UAC implementation to run installer/app as a normal user instead of administrator (WhatsApp Desktop, Smartflix, Squirrel Installers, OneDrive)
+ - #44514  Elder Scrolls Online (Dragon Bones update) requires more than 32 samplers in pixel shaders with D3D11 renderer
+ - #45862  Multiple applications need MFCreateSinkWriterFromURL() implementation (Overwatch highlights, RadiAnt DICOM Viewer, Grand Theft Auto V Rockstar Editor)
+ - #48085  Wine error trying to install Mono after a version update
+ - #51957  Program started via HKLM\Software\Microsoft\Windows\CurrentVersion\App Paths should also be started if extension ".exe" is missing
+ - #52352  YI Home installer crashes on unimplemented urlmon.dll.414
+ - #52622  windows-rs 'lib' test crashes on unimplemented function d3dcompiler_47.dll.D3DCreateLinker
+ - #53613  Visual novel RE:D Cherish! logo video and opening movie does not play
+ - #53635  Alune Klient 14.03.2022 crashes on unimplemented function urlmon.dll.414
+ - #54155  WeCom (aka WeChat Work) 4.x failed to launch.
+ - #55421  Fallout Tactics launcher has graphics glitches
+ - #55876  Acrom Controller Updater broken due to oleaut32 install
+ - #56318  Totem Arts Launcher.exe does not open
+ - #56367  Tomb Raider 3 GOG crashes at start
+ - #56379  d2d1 unable to build
+ - #56380  Rocket League crashes with Wine 9.3 after BakkesMod (trainer app) injects into the game
+ - #56400  SSPI authentication does not work when connecting to sql server
+ - #56406  wineserver crashes in set_input_desktop()
+ - #56411  Failure to build wine 9.4 due to EGL 64-bit development files not found
+ - #56433  QQ8.9.6 Installer crashes at very beginning due to a change in server/process.c
+ - #56434  WScript.Network does not implement UserName, ComputerName, and UserDomain properties
+ - #56435  capture mouse dont work in virtual desktop (work on wine 9.3)
+ - #56445  d3d1-9 applications run out of memory after f6a1844dbe (ArmA: Cold War Assault, Final Fantasy XI Online, Far Cry 3)
+ - #56450  Non-input USB HID devices stopped working in 9.1
+ - #56458  ntdll tests skipped on win7 & win8: missing entry point kernel32.RtlPcToFileHeader
+
+### Changes since 9.4:
+```
+Akihiro Sagawa (2):
+      dsound/tests: Add tests for implicit MTA creation in IDirectSound::Initialize().
+      dsound: Initialize MTA in IDirectSound::Initialize().
+
+Alexandre Julliard (42):
+      configure: Check the correct variable for the Wayland EGL library.
+      ntdll: Implement RtlRestoreContext on ARM64EC.
+      ntdll: Implement RtlWalkFrameChain on x86-64.
+      ntdll: Implement RtlWalkFrameChain on i386.
+      ntdll: Implement RtlWalkFrameChain on ARM.
+      ntdll: Implement RtlWalkFrameChain on ARM64.
+      ntdll: Implement RtlWalkFrameChain on ARM64EC.
+      ntdll: Export RtlVirtualUnwind2 and RtlWalkFrameChain.
+      ntdll: Share RtlCaptureStackBackTrace implementation across platforms.
+      secur32/tests: Update count for new winehq.org certificate.
+      ws2_32/tests: Fix a couple of failures on Windows.
+      include: Define setjmpex prototype even when it's a builtin.
+      ntdll/tests: Directly link to setjmp().
+      ntdll/tests: Fix a backtrace test failure on Windows ARM64.
+      ntdll: Add test for non-volatile regs in consolidated unwinds.
+      ntdll: Port the RtlRestoreContext test to ARM64.
+      ntdll: Port the RtlRestoreContext test to ARM.
+      ntdll: Implement RtlUnwindEx on ARM64EC.
+      ntdll: Move __C_specific_handler implementation to unwind.c.
+      ntdll: Implement __C_specific_handler on ARM64EC.
+      ntdll: Always use SEH support on ARM64.
+      ntdll/tests: Skip segment register tests on ARM64EC.
+      ntdll/tests: Fix debug register tests on ARM64EC.
+      ntdll/tests: Fix a few more test failures on ARM64EC.
+      ntdll: Implement RtlGetCallersAddress.
+      kernelbase: Remove no longer needed DllMainCRTStartup function.
+      include: Add some new error codes.
+      include: Add some new status codes.
+      ntdll: Add mappings for more status codes.
+      jscript: Use the correct facility for JScript errors.
+      netprofm: Use the correct symbols for error codes.
+      msvcrt: Use floating point comparison builtins also in MSVC mode.
+      ntdll/tests: Fix exception address checks in child process on ARM64EC.
+      ntdll/tests: Update the KiUserExceptionDispatcher test for ARM64EC.
+      configure: Don't build wow64 support in non-PE builds.
+      wow64: Use a .seh handler in raise_exception().
+      wow64: Always use a .seh handler in cpu_simulate().
+      wow64: Access the BTCpuSimulate backend function pointer directly.
+      wow64: Use a .seh handler for system calls.
+      wow64cpu: Save non-volatile registers before switching to 32-bit code.
+      wow64: Use setjmp/longjmp from ntdll.
+      server: Add a helper to trace uint64 arrays.
+
+Alexandros Frantzis (5):
+      winewayland.drv: Implement wglCreateContextAttribsARB.
+      winewayland.drv: Implement wglShareLists.
+      winewayland.drv: Implement wgl(Get)SwapIntervalEXT.
+      win32u: Cancel auto-repeat only if the repeat key is released.
+      win32u: Cancel previous key auto-repeat when starting a new one.
+
+Andrew Nguyen (3):
+      ddraw: Reserve extra space in the reference device description buffer.
+      oleaut32: Bump version resource to Windows 10.
+      ddraw: Release only valid texture parents on ddraw_texture_init failure.
+
+Andrew Wesie (1):
+      wined3d: Use bindless textures for GLSL shaders if possible.
+
+Brendan McGrath (5):
+      comdlg32: Use values from DeviceCapabilities in combobox.
+      comdlg32: Add resolutions to PRINTDLG_ChangePrinterW.
+      comdlg32: Populate printer name on the print dialogs.
+      comdlg32: Use ANSI functions in ANSI WMCommandA.
+      comdlg32: Don't treat cmb1 as the printer list unless in PRINT_SETUP.
+
+Brendan Shanks (6):
+      ntdll: Remove support for msg_accrights FD passing.
+      server: Remove support for msg_accrights FD passing.
+      mountmgr: Replace sprintf with snprintf to avoid deprecation warnings on macOS.
+      mountmgr: Replace some malloc/sprintf/strcpy calls with asprintf.
+      opengl32: Replace sprintf with snprintf/asprintf to avoid deprecation warnings on macOS.
+      secur32: Replace sprintf with snprintf to avoid deprecation warnings on macOS.
+
+Daniel Lehman (2):
+      oleaut32/tests: Add tests for GetSizeMax after dirty flag cleared.
+      oleaut32: Return success from GetSizeMax if not dirty.
+
+David Gow (1):
+      evr/dshow: Support NV12 in evr_render.
+
+David Heidelberg (2):
+      d3d9/tests: Replace LPDWORD cast with float_to_int function.
+      mailmap: Add a mailmap entry for myself with the proper name.
+
+Dmitry Timoshkov (6):
+      d2d1: Make some strings const.
+      wineps.drv: Return default resolution if PPD doesn't provide the list of supported resolutions.
+      kerberos: Allocate memory for the output token if requested.
+      comctl32/tests: Add more tests for IImageList2 interface.
+      comctl32: Implement IImageList2::Initialize().
+      widl: Add initial implementation of SLTG typelib generator.
+
+Eric Pouech (18):
+      include: Update minidumpapiset.h.
+      dbghelp/tests: Add tests for minidumps.
+      dbghelp/tests: Add tests about generated memory chunks.
+      dbghelp/tests: Add tests about minidump's callback.
+      dbghelp/tests: Test exception information in minidump.
+      dbghelp/tests: Add tests for function table lookup.
+      dbghelp: Use an intermediate buffer in SymFunctionTableAccess (x86_64).
+      dbghelp: Don't write minidump from running thread.
+      dbghelp: Simplify thread info generation in minidump.
+      dbghelp: Add support for V2 unwind info (x86_64).
+      winedbg: Fallback to PE image when reading memory (minidump).
+      winedbg: Reload module without virtual flag.
+      dbghelp: No longer embed unwind information in minidump (x86_64).
+      winedbg: Add ability to set executable name.
+      winedbg: Extend 'attach' command to load minidump files.
+      winedbg: Flush expr buffer upon internal exception.
+      winedbg: Update the CPU information displayed when reloading a minidump.
+      winedbg: Don't reload a minidump for a different machine.
+
+Esme Povirk (7):
+      user32/tests: Accept HCBT_ACTIVATE in TrackPopupMenu.
+      gdiplus: Check bounding box in GdipIsVisibleRegionPoint.
+      user32/tests: Add another missing message for TrackPopupMenu.
+      gdiplus/tests: Region bounds aren't rounded.
+      gdiplus: Calculate region bounding box without generating HRGN.
+      user32/tests: Accept WM_ACTIVATE in TrackPopupMenu.
+      user32/tests: Further updates for win11 TrackPopupMenu failures.
+
+Gabriel Ivăncescu (1):
+      shell32: Construct the proper path target for UnixFolder.
+
+Giovanni Mascellani (1):
+      d2d1: Compile the pixel shader with D3DCompile().
+
+Hans Leidekker (3):
+      dnsapi/tests: Skip tests if no CNAME records are returned.
+      ntdll/tests: Fix a test failure.
+      ntdll/tests: Load NtMakeTemporaryObject() dynamically.
+
+Henri Verbeet (1):
+      wined3d: Do not check the input signature element count for sm4+ shaders in shader_spirv_compile_arguments_init().
+
+Jacek Caban (2):
+      configure: Don't explicitly enable -Wenum-conversion on Clang.
+      widl: Always close parsed input file.
+
+Jinoh Kang (10):
+      tools/gitlab: Run make_specfiles before building.
+      ntdll/tests: Add tests for OBJ_PERMANENT object attribute.
+      ntdll/tests: Add tests for NtMakeTemporaryObject.
+      server: Generalize server request make_temporary to set_object_permanence.
+      ntdll: Implement NtMakePermanentObject.
+      ntdll/tests: Don't import kernel32.RtlPcToFileHeader.
+      Revert "ntdll/tests: Load NtMakeTemporaryObject() dynamically."
+      server: Check for DELETE access in NtMakeTemporaryObject().
+      kernelbase: Open object with DELETE access for NtMakeTemporaryObject().
+      gitlab: Output collapsible section markers in test stage script.
+
+Kyrylo Babikov (1):
+      dbghelp: Fix PDB processing using the FPO stream instead of FPOEXT.
+
+Louis Lenders (1):
+      shell32: Try appending .exe when looking up an App Paths key.
+
+Marcus Meissner (1):
+      ntdll/tests: Fix size passed to GetModuleFileNameW.
+
+Mark Jansen (1):
+      kernel32/tests: Add tests for job object accounting.
+
+Nikolay Sivov (16):
+      include: Add ID2D1Factory7 definition.
+      include: Add ID2D1DeviceContext6 definition.
+      d3dcompiler: Set correct compilation target for effects profiles.
+      d3dcompiler: Wrap fx_4_x output in a dxbc container.
+      d3d10/tests: Add a small effect compilation test.
+      wshom/network: Use TRACE() for implemented method.
+      wshom/network: Implement GetTypeInfo().
+      wshom/network: Implement ComputerName() property.
+      wshom/network: Check pointer argument in get_UserName().
+      d3dx10/tests: Remove todo's from now passing tests.
+      d3d10_1/tests: Remove todo from now passing test.
+      wshom/network: Implement UserDomain property.
+      msxml6/tests: Add some tests for MXWriter60.
+      msxml/tests: Move some of the validation tests to their modules.
+      msxml/tests: Move version-specific schema tests to corresponding modules.
+      include: Remove XMLSchemaCache60 from msxml2.idl.
+
+Noah Berner (1):
+      advapi32/tests: Add todo_wine to tests that are currently failing.
+
+Paul Gofman (11):
+      imm32: Set lengths to 0 for NULL strings in ImmSetCompositionString().
+      cryptowinrt: Force debug info in critical sections.
+      diasymreader: Force debug info in critical sections.
+      dsdmo: Force debug info in critical sections.
+      qasf: Force debug info in critical sections.
+      services: Force debug info in critical sections.
+      explorer: Force debug info in critical sections.
+      ntdll: Only allocate debug info in critical sections with RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO.
+      server: Ignore some ICMP-originated socket errors for connectionless sockets.
+      strmbase: Fallback to InitializeCriticalSection() if RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO is unsupported.
+      ntdll: Don't use debug info presence to detect critical section global status.
+
+Pavel Ondračka (1):
+      d3d9/tests: Define enums outside of struct.
+
+Piotr Caban (6):
+      ntdll: Workaround sendmsg bug on macOS.
+      winedump: Fix REG_DWORD dumping with no data.
+      advapi32/tests: Merge RegLoadKey and RegUnLoadKey tests.
+      advapi32/tests: Remove all files created by RegLoadKey tests.
+      advapi32/tests: Test if modifications are saved in RegUnLoadKey.
+      advapi32/tests: Remove all files created by RegLoadAppKey tests.
+
+Robin Kertels (1):
+      d3d9/tests: Skip desktop window tests if device creation fails.
+
+Rémi Bernon (74):
+      win32u: Move D3DKMT functions to a new d3dkmt.c source.
+      win32u: Move D3DKMT VidPn* functions out of winex11.
+      win32u: Add an adapter struct to the device manager context.
+      win32u: Split writing monitor to registry to a separate helper.
+      win32u: Get rid of the monitor display_device.
+      win32u: Get rid of the monitor state_flags.
+      win32u: Get rid of the adapter display_device.
+      win32u: Get rid of the monitor flags.
+      win32u: Enumerate monitors from their device keys.
+      mfreadwrite/reader: Handle MF_E_TRANSFORM_STREAM_CHANGE results.
+      win32u: Fix incorrect ascii key name in get_config_key.
+      winevulkan: Use an rb_tree and allocate entries for handle mappings.
+      winevulkan: Use a single allocation for device and queues.
+      winevulkan: Pass VkDeviceQueueCreateInfo to wine_vk_device_init_queues.
+      winevulkan: Rename wine_vk_physical_device_alloc parameters and variables.
+      winevulkan: Use a single allocation for instance and physical devices.
+      winevulkan: Get rid of the wine_vk_device_free helper.
+      winevulkan: Simplify wine_vk_instance_free helper.
+      winevulkan: Add handle mappings on creation success only.
+      winevulkan: Get rid of the wine_vk_instance_free helper.
+      mfplat/tests: Test each VIDEOINFOHEADER field conversion separately.
+      mfplat/mediatype: Implement implicit MFInitMediaTypeFromVideoInfoHeader subtype.
+      mfplat/mediatype: Implement MFInitMediaTypeFromVideoInfoHeader2.
+      mfplat/tests: Add tests for MFInitMediaTypeFromVideoInfoHeader2.
+      mfplat/mediatype: Implement MFInitAMMediaTypeFromMFMediaType for FORMAT_VideoInfo2.
+      mfplat/tests: Test aperture to VIDEOINFOHEADER fields mapping.
+      mfplat/mediatype: Support FORMAT_VideoInfo2 in MFInitMediaTypeFromAMMediaType.
+      mfplat/mediatype: Set MF_MT_SAMPLE_SIZE from bmiHeader.biSizeImage.
+      mfplat/mediatype: Map rcSource to MF_MT_(PAN_SCAN|MINIMUM_DISPLAY)_APERTURE.
+      mfplat/mediatype: Set rcSource and rcTarget if stride differs from width.
+      mfplat/tests: Add more MFAverageTimePerFrameToFrameRate tests.
+      mfplat: Support flexible frame time in MFAverageTimePerFrameToFrameRate.
+      mfplat/mediatype: Implement MF_MT_FRAME_RATE from VIDEOINFOHEADER2.
+      mfplat/mediatype: Implement VIDEOINFOHEADER2 dwControlFlags conversion.
+      mfplat/mediatype: Implement some VIDEOINFOHEADER2 dwInterlaceFlags conversion.
+      mfplat/tests: Test that aperture is dropped with VIDEOINFOHEADER2.
+      mfplat/tests: Test that MFCreateMFVideoFormatFromMFMediaType appends user data.
+      mfplat/mediatype: Append user data in MFCreateMFVideoFormatFromMFMediaType.
+      mfplat/tests: Check the conditions for the MFVideoFlag_BottomUpLinearRep flags.
+      mfplat/mediatype: Stub MFInitMediaTypeFromMFVideoFormat.
+      mfplat/tests: Add tests for MFInitMediaTypeFromMFVideoFormat.
+      mfplat/mediatype: Implement MFInitMediaTypeFromMFVideoFormat.
+      winebus: Add HID usages in the device descriptor when possible.
+      winebus: Read hidraw device usages from their report descriptors.
+      winebus: Prefer hidraw for everything that is not a game controller.
+      winebus: Remove devices that are ignored wrt hidraw preferences.
+      winevulkan: Allow only one vulkan surface at a time for an HWND.
+      win32u: Avoid a crash when cleaning up a monitor without an adapter.
+      winegstreamer: Release sink caps in the error path.
+      winegstreamer: Append an optional parser before decoders.
+      mfplat/tests: Add some broken results for Win7.
+      mfplat/tests: Test initializing mediatype from AAC WAVEFORMATEXTENSIBLE.
+      mfplat/tests: Check how AAC attributes are copied from user data.
+      mfplat/mediatype: Check format pointers and sizes in MFInitMediaTypeFromAMMediaType.
+      mfplat/mediatype: Support audio major type in MFInitMediaTypeFromAMMediaType.
+      mfplat/mediatype: Force WAVEFORMATEXTENSIBLE in MFCreateWaveFormatExFromMFMediaType in some cases.
+      mfplat/mediatype: Implement MFCreateMediaTypeFromRepresentation.
+      mfplat/mediatype: Use MFCreateWaveFormatExFromMFMediaType in init_am_media_type_audio_format.
+      ntoskrnl.exe: Open symbolic link with DELETE before making them temporary.
+      server: Avoid removing thread twice from its desktop thread list.
+      winex11: Accept key and mouse events with QS_RAWINPUT.
+      server: Send WM_WINE_CLIPCURSOR message only when necessary.
+      server: Send WM_WINE_SETCURSOR message only when necessary.
+      win32u: Use a structure to pass peek_message arguments.
+      server: Check for internal hardware messages before others.
+      server: Process internal messages when checking queue status.
+      user32/tests: Add missing winetest_pop_context.
+      user32/tests: Add some LoadKeyboardLayoutEx tests.
+      winemac: Use SONAME_LIBVULKAN as an alias for MoltenVK.
+      win32u: Move vulkan loading and init guard out of the drivers.
+      win32u: Move vkGet(Instance|Device)ProcAddr out the drivers.
+      winevulkan: Stop generating the wine/vulkan_driver.h header.
+      win32u: Move vkGet(Device|Instance)ProcAddr helpers inline.
+      mfplat: Append MFVIDEOFORMAT user data after the structure padding.
+
+Santino Mazza (2):
+      mf/test: Check the topologies id's in topo loader.
+      mf/topoloader: Preserve input topology id.
+
+Vijay Kiran Kamuju (4):
+      include: Add Windows.UI.ViewManagement.UIViewSettings definitions.
+      urlmon: Add stub for ordinal 414.
+      d3dcompiler: Add D3DCreateLinker stub.
+      user32: Add LoadKeyboardLayoutEx stub.
+
+Yuxuan Shui (8):
+      shell32/tests: Check FindExecutable is looking in the correct current directory.
+      shell32/tests: Check ShellExecute is looking in the correct current directory.
+      shell32: PathResolve(file, NULL, ...) should not look in the current directory.
+      shell32: Make sure PathResolve can find files in the current directory.
+      shell32: PathResolve should be able to find files that already have extensions.
+      shell32: PathResolve should remove trailing dot.
+      shell32: Fix FindExecutable search path.
+      shell32: Rely solely on SHELL_FindExecutable for ShellExecute.
+
+Zebediah Figura (12):
+      ntdll: Assign a primary token in elevate_token().
+      d3d9/tests: Remove a no longer accurate comment.
+      d3d11/tests: Add a test for using a large number of SRV resources.
+      wined3d: Rename the shader_select_compute method to shader_apply_compute_state.
+      wined3d: Move checking shader_update_mask to shader_glsl_apply_compute_state().
+      shell32/tests: Remove obsolete workarounds from test_move().
+      quartz: Implement SetVideoClippingWindow() and PresentImage() in the VMR7 presenter.
+      quartz: Reimplement the VMR7 using the VMR7 presenter.
+      quartz: Implement IVMRSurfaceAllocatorNotify::AdviseSurfaceAllocator().
+      quartz: Return S_OK from IVMRSurfaceAllocator_PrepareSurface().
+      quartz/tests: Add some tests for VMR7 renderless mode.
+      wined3d: Avoid leaking string buffers in shader_glsl_load_bindless_samplers().
+
+Zhenbo Li (1):
+      shell32: Create nonexistent destination directories in FO_MOVE.
+
+Zhiyi Zhang (5):
+      mfreadwrite: Fix a memory leak (Coverity).
+      win32u: Support HiDPI for the non-client close button in WS_EX_TOOLWINDOW windows.
+      win32u: Fix a possible condition that makes EnumDisplayMonitors() not reporting any monitors.
+      win32u: Don't enumerate mirrored monitor clones for GetSystemMetrics(SM_CMONITORS).
+      win32u: Don't enumerate mirrored monitor clones when unnecessary.
+```
--- a/49
+++ b/49
@ -25,6 +25,7 @@ Adrian Bunk
 Adrian Harvey
 Adrian Thiele
 Adrian Thurston
+Aida Jonikienė
 Aidan Thornton
 Ake Rehnman
 Akihiro Sagawa
@ -77,6 +78,7 @@ Alexey Markachev
 Alexey Prokhin
 Alexey Spiridonov
 Alex Henrie
+Alexis Murzeau
 Alex Korobka
 Alex Pasadyn
 Alex Priem
@ -85,8 +87,10 @@ Alex Villacís Lasso
 Alex Woods
 Alex Zorach
 Alfons Hoogervorst
+Alfred Agrell
 Alistair Leslie-Hughes
 Allan Tong
+Ally Sommers
 Alon Barzilai
 Álvaro Nieto
 Ambrož Bizjak
@ -118,6 +122,7 @@ Andre Malafaya Baptista
 Andrew Bogott
 Andrew Borodin
 Andrew Boyarshin
+Andrew Brobston
 Andrew Bulhak
 Andrew Church
 Andrew Cook
@ -217,6 +222,7 @@ Bill Currie
 Bill Hawes
 Bill Jin
 Bill Medland
+Billy Laws
 Biswapriyo Nath
 Björn Bidar
 Blake Leverett
@ -354,6 +360,7 @@ Dan Hipschman
 Daniel Ansorregui
 Daniel Beitler
 Daniel Gudbjartsson
+Daniel Hill
 Daniel Jelinski
 Daniel Lehman
 Daniel Lund
@ -366,6 +373,7 @@ Daniel Santos
 Daniel Scharrer
 Daniel Schepler
 Daniel Skorka
+Daniel Tang
 Daniel Verkamp
 Daniel Walker
 Daniel Zimmermann
@ -397,7 +405,7 @@ David Gow
 David Grant
 David Hammerton
 David Hedberg
-David Heidelberger
+David Heidelberg
 David Hemmo
 David Howells
 David Kahurani
@ -412,6 +420,7 @@ David Lee Lambert
 David Lichterman
 David Luyer
 David McCullough
+David McFarland
 David Metcalfe
 David Miller
 David Moore
@ -423,6 +432,7 @@ David Welch
 David White
 David Woodhouse
 Davin McCall
+Dāvis Mosāns
 Dean M Greer
 Denil Verghese
 Denis Baranov
@ -444,6 +454,7 @@ Dmitriy Anisimkov
 Dmitry Kislyuk
 Dmitry Kozliuk
 Dmitry Potapov
+Dmitry Sokolov
 Dmitry Timoshkov
 Dominik Strasser
 Donat Enikeev
@ -474,6 +485,7 @@ Ed Snow
 Eduardo García
 Eduard Permyakov
 EG Galano
+Ekaterine Papava
 Elias Benali
 Elias Ross
 Elie Morisse
@ -529,6 +541,7 @@ Fatih Aşıcı
 Federico Schwindt
 Felix Hädicke
 Felix Janda
+Felix Münchhalfen
 Felix Nawothnig
 Ferenc Wagner
 Fergal Daly
@ -563,6 +576,7 @@ Freddie Tilley
 Frederic Boulanger
 Frédéric Delanoy
 Frédéric Fauberteau
+Gabriel Brand
 Gabriel Buades Rubio
 Gabriele Giorgetti
 Gabriele Moabiti
@ -577,6 +591,7 @@ Gavriel State
 Gediminas Jakutis
 Geoff Clare
 Geoffrey Hausheer
+Geoffrey McRae
 Geoff Thorpe
 Georg Beyerle
 George Gov
@ -635,6 +650,7 @@ Hann-huei Chiou
 Hannu Valtonen
 Hans de Graaff
 Hans-Kristian Arntzen
+Hans Lehnert
 Hans Leidekker
 Hao Peng
 Haoyang Chen
@ -645,6 +661,7 @@ Harry McNally
 Hartmut Birr
 Hasan Kiran
 Heiko Hund
+Helix Graziani
 Henning Gerhardt
 Henning Hoffmann
 Henrik Olsen
@ -685,6 +702,7 @@ Igor Paliychuk
 Igor Stepin
 Igor Tarasov
 Ihsan Akmal
+Ilia Docin
 Ilia Mirkin
 Illia Polishchuk
 Ilya Basin
@ -726,6 +744,7 @@ Jakob Eriksson
 Jakub Bartmiński
 Jakub Staroń
 James Abbatiello
+James Beddek
 James Courtier-Dutton
 James Dean Anderson
 James Eder
@ -955,6 +974,7 @@ Karl Lessard
 Karl Relton
 Karol Herbst
 Karsten Elfenbein
+Kartavya Vashishtha
 Kasper Sandberg
 Katarzyna Caban
 K.B.Dharun Krishna
@ -980,6 +1000,7 @@ Kevin Holbrook
 Kevin Koltzau
 Kevin Krammer
 Kevin Puetz
+Kevin Schmidt
 Kieran Clancy
 Kieran Duggan
 Kim Geonwoo (김건우)
@ -1015,11 +1036,14 @@ Kristian Nielsen
 Kristján Gerhardsson
 Kristofer Henriksson
 Kristoffer Gleditsch
+Krzysztof Bogacki
 Krzysztof Foltman
 Krzysztof Kotlenga
 Krzysztof Nowicki
+Kurt Kartaltepe
 Kusanagi Kouichi
 Kyle Luna
+Kyrylo Babikov
 Lance Jackson
 Lars-Ake Fredlund
 Lars Heete
@ -1074,6 +1098,7 @@ Lukáš Krejčí
 Luke Benstead
 Luke Bratch
 Luke Deller
+Maarten De Braekeleer
 Maarten Lankhorst
 Maciej Borsz
 Maciek Kaliszewski
@ -1084,6 +1109,7 @@ Maksim Kuleshov
 Malte Starostik
 Manfred Weichel
 Manuel Edelmann
+Marc-Aurel Zent
 Marc Bessières
 Marcel Baur
 Marcel Hasler
@ -1172,6 +1198,7 @@ Mauro Carvalho Chehab
 Max Figura
 Maxime Bellengé
 Maxime Lombard
+Maxim Karasev
 Max Kellermann
 Max Qian
 Max TenEyck Woodbury
@ -1205,6 +1232,7 @@ Michael Patra
 Michael Ploujnikov
 Michael Poole
 Michael Schlüter
+Michael Skorokhodov
 Michael Stefaniuc
 Michael Veksler
 Michael Wetherell
@ -1263,11 +1291,13 @@ Nathan Zorich
 Naveen Narayanan
 Neil Olver
 Neil Skrypuch
+Nell Hardcastle
 Nemeth Peter
 Nerijus Baliunas
 Nguyễn Chính Hữu
 Nicholas Fraser
 Nicholas Niro
+Nicholas Tay
 Nick Bowler
 Nick Burns
 Nick Fox
@ -1283,6 +1313,7 @@ Niels Kristian Bech Jensen
 Nigel Liang
 Nikita Morozkin
 Nikita V. Youshchenko
+Nikola Kuburović
 Nikola Pavlica
 Nikolas Zimmermann
 Nikolay Bogoychev
@ -1290,6 +1321,7 @@ Nikolay Sivov
 Nikolay Stefanov
 Nils Kuhnhenn
 Nix N. Nix
+Noah Berner
 Noel Borthwick
 Noomen Hamza
 Norman Stevens
@ -1357,9 +1389,11 @@ Paul van Schayck
 Paul Vriens
 Pavel Borecki
 Pavel Kankovsky
+Pavel Ondračka
 Pavel Roskin
 Pavel Semerad
 Pavel Troller
+Paweł Ulita
 Pedro Araujo Chaves Jr
 Pedro Maia
 Pedro Perdigão
@ -1398,6 +1432,7 @@ Peter Schlaile
 Peter Urbanec
 Peter Verthez
 Petr Dlouhý
+Petrichor Park
 Petri Tuomola
 Petr Kočandrle
 Petr Sumbera
@ -1451,6 +1486,7 @@ Ralf S. Engelschall
 Ramon Garcia
 Randy Weems
 Raphael Junqueira
+Rastislav Stanik
 Raul Dias
 Raul Fernandes
 Raul Metsma
@ -1537,6 +1573,7 @@ Rudolf Mayerhofer
 Ruei-Yuan Lu
 Ruslan Kabatsayev
 Russ Andersson
+Russell Greene
 Rustam Chernotkach
 Ryan Cumming
 Ryan Hendrickson
@ -1570,6 +1607,7 @@ Sean Young
 Sebastián Aedo
 Sebastian Gasiorek
 Sebastian Lackner
+Sebastian Mayr
 Sébastien Ramage
 Seong-ho Cho
 Serge Gautherie
@ -1739,6 +1777,7 @@ Tristan Schmelcher
 Tristan Tarrant
 Troy Rollo
 Trygve Vea
+Tyson Whitehead
 Ulrich Czekalla
 Ulrich Hecht
 Ulrich Schmid
@ -1753,6 +1792,9 @@ Valery Kartel
 Vasily I. Volchenko
 Vasudev Mulchandani
 Vedran Rodic
+Vibhav Pant
+Vicki Pfau
+Victor Chiletto
 Victor Hermann Chiletto
 Victor Martinez Calvo
 Victor Pelt
@ -1779,6 +1821,7 @@ Vladimir Panteleev
 Vladislav Timonin
 Volkan Gezer
 Volodymyr M. Shcherbyna
+Vova Mshanetskiy
 VRan Liu
 Wade Gobel
 Waldeck Schutzer
@ -1814,9 +1857,11 @@ Wolfgang Schwotzer
 Wolfgang Thaller
 Wolfgang Walter
 Wolfram Sang
+Wonjun Jung
 Won Kyu Park
 Xiang Li
 Xiaoshan Sun
+Xin Xu
 XueFeng Chang
 Yann Droneaud
 Yaron Shahrabani
@ -1836,6 +1881,7 @@ Yuriy Kaminskiy
 Yussur-Mustafa Oraji
 Yuval Fledel
 Yuxi Zhang
+Yuxuan Shui
 Yvon Belleau
 Zachary Brown
 Zach Goldberg
@ -1857,4 +1903,5 @@ Zixing Liu
 Zoltan Kovacs
 Zoltan Nagy
 Zoran Dzelajlija
+Zsolt Vadasz
 Zygo Blaxell
--- a/2
+++ b/2
@ -1,4 +1,4 @@
-Copyright (c) 1993-2023 the Wine project authors (see the file AUTHORS
+Copyright (c) 1993-2024 the Wine project authors (see the file AUTHORS
 for a complete list)

 Wine is free software; you can redistribute it and/or modify it under
--- a/16
+++ b/16
@ -29,7 +29,8 @@ Maintainers List
 		-----------------------------------

 ARM, ARM64
-M:	André Zwing <nerv@dawncrow.de>
+M:	Alexandre Julliard <julliard@winehq.org>
+P:	André Zwing <nerv@dawncrow.de>
 F:	dlls/dbghelp/cpu_arm*
 F:	dlls/msvcrt/except_arm.c
 F:	dlls/ntdll/signal_arm*
@ -168,6 +169,7 @@ P:	Aric Stewart <aric@codeweavers.com>
 F:	dlls/hid/
 F:	dlls/hidclass.sys/
 F:	dlls/hidparse.sys/
+F:	dlls/mouhid.sys/
 F:	dlls/winehid.sys/

 HTTP server
@ -183,8 +185,12 @@ F:	dlls/win32u/rawinput.c
 F:	server/queue.c

 Input methods
-M:	Aric Stewart <aric@codeweavers.com>
+M:	Rémi Bernon <rbernon@codeweavers.com>
+P:	Aric Stewart <aric@codeweavers.com>
 F:	dlls/imm32/
+F:	dlls/win32u/imm.c
+F:	dlls/winemac.drv/ime.c
+F:	dlls/winex11.drv/ime.c

 JavaScript
 M:	Jacek Caban <jacek@codeweavers.com>
@ -205,14 +211,15 @@ P:	Andrew Eikum <coldpie@fastmail.com>
 F:	dlls/*.acm/
 F:	dlls/msacm32/

-Media Foundation transforms
+Media Foundation GStreamer backend
 M:	Rémi Bernon <rbernon@codeweavers.com>
 P:	Nikolay Sivov <nsivov@codeweavers.com>
 P:	Zebediah Figura <z.figura12@gmail.com>
 F:	dlls/mf/tests/transform.c
 F:	dlls/winegstreamer/aac_decoder.c
 F:	dlls/winegstreamer/color_convert.c
-F:	dlls/winegstreamer/h264_decoder.c
+F:	dlls/winegstreamer/media_source.c
+F:	dlls/winegstreamer/mfplat.c
 F:	dlls/winegstreamer/resampler.c
 F:	dlls/winegstreamer/video_decoder.c
 F:	dlls/winegstreamer/video_processor.c
@ -366,6 +373,7 @@ F:	dlls/wmvcore/
 Windows Media Foundation
 M:	Nikolay Sivov <nsivov@codeweavers.com>
 P:	Rémi Bernon <rbernon@codeweavers.com>
+F:	dlls/evr/
 F:	dlls/mf/
 F:	dlls/mferror/
 F:	dlls/mfmediaengine/
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-1. INTRODUCTION
+## INTRODUCTION

 Wine is a program which allows running Microsoft Windows programs
 (including DOS, Windows 3.x, Win32, and Win64 executables) on Unix.
@ -11,77 +11,79 @@ Wine is free software, released under the GNU LGPL; see the file
 LICENSE for the details.


-2. QUICK START
+## QUICK START

 From the top-level directory of the Wine source (which contains this file),
 run:

+```
 ./configure
 make
+```

 Then either install Wine:

+```
 make install
+```

 Or run Wine directly from the build directory:

+```
 ./wine notepad
+```

-Run programs as "wine program".  For more information and problem
+Run programs as `wine program`. For more information and problem
 resolution, read the rest of this file, the Wine man page, and
 especially the wealth of information found at https://www.winehq.org.


-3. REQUIREMENTS
+## REQUIREMENTS

 To compile and run Wine, you must have one of the following:

-  Linux version 2.0.36 or later
-  FreeBSD 8.0 or later
-  Solaris x86 9 or later
-  NetBSD-current
-  Mac OS X 10.8 or later
+- Linux version 2.6.22 or later
+- FreeBSD 12.4 or later
+- Solaris x86 9 or later
+- NetBSD-current
+- Mac OS X 10.8 or later

 As Wine requires kernel-level thread support to run, only the operating
 systems mentioned above are supported.  Other operating systems which
 support kernel threads may be supported in the future.

-FreeBSD info:
-  Wine will generally not work properly on versions before FreeBSD 8.0.
+**FreeBSD info**:
  See https://wiki.freebsd.org/Wine for more information.

-Solaris info:
+**Solaris info**:
  You will most likely need to build Wine with the GNU toolchain
  (gcc, gas, etc.). Warning : installing gas does *not* ensure that it
  will be used by gcc. Recompiling gcc after installing gas or
  symlinking cc, as and ld to the gnu tools is said to be necessary.

-NetBSD info:
+**NetBSD info**:
  Make sure you have the USER_LDT, SYSVSHM, SYSVSEM, and SYSVMSG options
  turned on in your kernel.

-Mac OS X info:
+**Mac OS X info**:
  You need Xcode/Xcode Command Line Tools or Apple cctools.  The
  minimum requirements for compiling Wine are clang 3.8 with the
  MacOSX10.10.sdk and mingw-w64 v8.  The MacOSX10.14.sdk and later can
  only build wine64.

-
-Supported file systems:
+**Supported file systems**:
  Wine should run on most file systems. A few compatibility problems
  have also been reported using files accessed through Samba. Also,
  NTFS does not provide all the file system features needed by some
  applications.  Using a native Unix file system is recommended.

-Basic requirements:
+**Basic requirements**:
  You need to have the X11 development include files installed
  (called xorg-dev in Debian and libX11-devel in Red Hat).
-
-  Of course you also need "make" (most likely GNU make).
-
+  Of course you also need make (most likely GNU make).
  You also need flex version 2.5.33 or later and bison.

-Optional support libraries:
+**Optional support libraries**:
  Configure will display notices when optional libraries are not found
  on your system. See https://wiki.winehq.org/Recommended_Packages for
  hints about the packages you should install. On 64-bit platforms,
@ -89,80 +91,80 @@ Optional support libraries:
  libraries.


-4. COMPILATION
+## COMPILATION

 To build Wine, do:

+```
 ./configure
 make
+```

 This will build the program "wine" and numerous support libraries/binaries.
 The program "wine" will load and run Windows executables.
 The library "libwine" ("Winelib") can be used to compile and link
 Windows source code under Unix.

-To see compile configuration options, do ./configure --help.
+To see compile configuration options, do `./configure --help`.

 For more information, see https://wiki.winehq.org/Building_Wine


-5. SETUP
+## SETUP

-Once Wine has been built correctly, you can do "make install"; this
+Once Wine has been built correctly, you can do `make install`; this
 will install the wine executable and libraries, the Wine man page, and
 other needed files.

 Don't forget to uninstall any conflicting previous Wine installation
-first.  Try either "dpkg -r wine" or "rpm -e wine" or "make uninstall"
+first.  Try either `dpkg -r wine` or `rpm -e wine` or `make uninstall`
 before installing.

-Once installed, you can run the "winecfg" configuration tool. See the
+Once installed, you can run the `winecfg` configuration tool. See the
 Support area at https://www.winehq.org/ for configuration hints.


-6. RUNNING PROGRAMS
+## RUNNING PROGRAMS

 When invoking Wine, you may specify the entire path to the executable,
 or a filename only.

-For example: to run Notepad:
+For example, to run Notepad:

-    wine notepad            (using the search Path as specified in
-    wine notepad.exe         the registry to locate the file)
+```
+wine notepad            (using the search Path as specified in
+wine notepad.exe         the registry to locate the file)

-    wine c:\\windows\\notepad.exe      (using DOS filename syntax)
+wine c:\\windows\\notepad.exe      (using DOS filename syntax)

-    wine ~/.wine/drive_c/windows/notepad.exe  (using Unix filename syntax)
+wine ~/.wine/drive_c/windows/notepad.exe  (using Unix filename syntax)

-    wine notepad.exe readme.txt          (calling program with parameters)
+wine notepad.exe readme.txt          (calling program with parameters)
+```

 Wine is not perfect, so some programs may crash. If that happens you
 will get a crash log that you should attach to your report when filing
 a bug.


-7. GETTING MORE INFORMATION
+## GETTING MORE INFORMATION

-WWW:	A great deal of information about Wine is available from WineHQ at
+- **WWW**: A great deal of information about Wine is available from WineHQ at
 	https://www.winehq.org/ : various Wine Guides, application database,
 	bug tracking. This is probably the best starting point.

-FAQ:	The Wine FAQ is located at https://www.winehq.org/FAQ
+- **FAQ**: The Wine FAQ is located at https://www.winehq.org/FAQ

-Wiki:	The Wine Wiki is located at https://wiki.winehq.org
+- **Wiki**: The Wine Wiki is located at https://wiki.winehq.org

-Gitlab: Wine development is hosted at https://gitlab.winehq.org
+- **Gitlab**: Wine development is hosted at https://gitlab.winehq.org

-Mailing lists:
+- **Mailing lists**:
 	There are several mailing lists for Wine users and developers;
 	see https://www.winehq.org/forums for more information.

-Bugs:	Report bugs to Wine Bugzilla at https://bugs.winehq.org
+- **Bugs**: Report bugs to Wine Bugzilla at https://bugs.winehq.org
 	Please search the bugzilla database to check whether your
 	problem is already known or fixed before posting a bug report.

-IRC:	Online help is available at channel #WineHQ on irc.libera.chat.
-
--
-Alexandre Julliard
-julliard@winehq.org
+- **IRC**: Online help is available at channel `#WineHQ` on irc.libera.chat.
--- a/2
+++ b/2
@ -1 +1 @@
-Wine version 8.3
+Wine version 9.5
--- a/aclocal.m4
+++ b/aclocal.m4
@ -65,12 +65,9 @@ AC_DEFUN([WINE_PATH_PKG_CONFIG],
 [WINE_CHECK_HOST_TOOL(PKG_CONFIG,[pkg-config])])

 AC_DEFUN([WINE_PATH_MINGW_PKG_CONFIG],
-[case "$host_cpu" in
-  i[[3456789]]86*)
-    ac_prefix_list="m4_foreach([ac_wine_cpu],[i686,i586,i486,i386],[ac_wine_cpu-w64-mingw32-pkg-config ])" ;;
-  *)
-    ac_prefix_list="$host_cpu-w64-mingw32-pkg-config" ;;
-esac
+[AS_VAR_IF([HOST_ARCH],[i386],
+           [ac_prefix_list="m4_foreach([ac_wine_cpu],[i686,i586,i486,i386],[ac_wine_cpu-w64-mingw32-pkg-config ])"],
+           [ac_prefix_list="$host_cpu-w64-mingw32-pkg-config"])
 AC_CHECK_PROGS(MINGW_PKG_CONFIG,[$ac_prefix_list],false)])

 dnl **** Extract the soname of a library ****
@ -216,11 +213,12 @@ AC_CACHE_CHECK([whether $CC supports $1], ac_var,
 ac_wine_try_cflags_saved_exeext=$ac_exeext
 CFLAGS="$CFLAGS -nostdlib -nodefaultlibs $1"
 ac_exeext=".exe"
-AC_LINK_IFELSE([AC_LANG_SOURCE([[int __cdecl mainCRTStartup(void) { return 0; }]])],
+AC_LINK_IFELSE([AC_LANG_SOURCE([[void *__os_arm64x_dispatch_ret = 0;
+int __cdecl mainCRTStartup(void) { return 0; }]])],
               [AS_VAR_SET(ac_var,yes)], [AS_VAR_SET(ac_var,no)])
 CFLAGS=$ac_wine_try_cflags_saved
 ac_exeext=$ac_wine_try_cflags_saved_exeext])
-AS_VAR_IF([ac_var],[yes],[m4_default([$2], [AS_VAR_APPEND([${wine_arch}_EXTRACFLAGS],[" $1"])], [$3])])dnl
+AS_VAR_IF([ac_var],[yes],[m4_default([$2], [AS_VAR_APPEND([${wine_arch}_EXTRACFLAGS],[" $1"])])], [$3])dnl
 AS_VAR_POPDEF([ac_var]) }])

 dnl **** Check whether the given MinGW header is available ****
@ -261,20 +259,6 @@ LIBS=$ac_wine_check_headers_saved_libs])
 AS_VAR_IF([ac_var],[yes],[$3],[$4])dnl
 AS_VAR_POPDEF([ac_var])])

-dnl **** Check if we can link an empty shared lib (no main) with special CFLAGS ****
-dnl
-dnl Usage: WINE_TRY_SHLIB_FLAGS(flags,[action-if-yes,[action-if-no]])
-dnl
-AC_DEFUN([WINE_TRY_SHLIB_FLAGS],
-[AS_VAR_PUSHDEF([ac_var], ac_cv_cflags_[[$1]])dnl
-ac_wine_try_cflags_saved=$CFLAGS
-CFLAGS="$CFLAGS $1"
-AC_LINK_IFELSE([AC_LANG_SOURCE([[void myfunc() {}]])],
-               [AS_VAR_SET(ac_var,yes)], [AS_VAR_SET(ac_var,no)])
-CFLAGS=$ac_wine_try_cflags_saved
-AS_VAR_IF([ac_var],[yes], [$2], [$3])dnl
-AS_VAR_POPDEF([ac_var])])
-
 dnl **** Check whether we need to define a symbol on the compiler command line ****
 dnl
 dnl Usage: WINE_CHECK_DEFINE(name),[action-if-yes,[action-if-no]])
@ -317,6 +301,7 @@ wine_fn_config_makefile ()
    AS_VAR_COPY([enable],[$[2]])
    case "$enable" in
      no) AS_VAR_APPEND([DISABLED_SUBDIRS],[" $[1]"]) ;;
+      yes) ;;
      *aarch64*|*arm*|*i386*|*x86_64*)
        if test -n "$PE_ARCHS"
        then
@ -326,7 +311,11 @@ wine_fn_config_makefile ()
            done
        else
            test $(expr ",$enable," : ".*,$HOST_ARCH,") -gt 0 || AS_VAR_APPEND([DISABLED_SUBDIRS],[" $[1]"])
-        fi;;
+        fi ;;
+      "")
+        case "$[1], $PE_ARCHS " in
+          programs/*,*\ arm64ec\ *) AS_VAR_APPEND([arm64ec_DISABLED_SUBDIRS],[" $[1]"]) ;;
+        esac ;;
    esac
 }

--- a/2028
+++ b/2028
--- a/configure.ac
+++ b/configure.ac
--- a/dlls/acledit/Makefile.in
+++ b/dlls/acledit/Makefile.in
@ -2,5 +2,5 @@ MODULE    = acledit.dll

 EXTRADLLFLAGS = -Wb,--prefer-native

-C_SRCS = \
+SOURCES = \
 	main.c
--- a/dlls/aclui/Makefile.in
+++ b/dlls/aclui/Makefile.in
@ -4,6 +4,6 @@ IMPORTS   = comctl32 user32 advapi32 gdi32

 EXTRADLLFLAGS = -Wb,--prefer-native

-C_SRCS = aclui_main.c
-
-RC_SRCS = aclui.rc
+SOURCES = \
+	aclui.rc \
+	aclui_main.c
--- a/dlls/activeds.tlb/Makefile.in
+++ b/dlls/activeds.tlb/Makefile.in
@ -2,4 +2,5 @@ MODULE = activeds.tlb

 EXTRADLLFLAGS = -Wb,--data-only

-IDL_SRCS = activeds_tlb.idl
+SOURCES = \
+	activeds_tlb.idl
--- a/dlls/activeds.tlb/activeds.tlb.spec
+++ b/dlls/activeds.tlb/activeds.tlb.spec
@ -1 +0,0 @@
-# no exported entry points
--- a/dlls/activeds/Makefile.in
+++ b/dlls/activeds/Makefile.in
@ -4,9 +4,7 @@ IMPORTS   = advapi32 ole32 oleaut32 uuid

 EXTRADLLFLAGS = -Wb,--prefer-native

-C_SRCS = \
+SOURCES = \
+	activeds.idl \
 	activeds_main.c \
 	pathname.c
-
-IDL_SRCS = \
-	activeds.idl
--- a/dlls/activeds/activeds_main.c
+++ b/dlls/activeds/activeds_main.c
@ -233,7 +233,7 @@ HRESULT WINAPI ADsGetLastError(LPDWORD perror, LPWSTR errorbuf, DWORD errorbufle
 */
 LPVOID WINAPI AllocADsMem(DWORD cb)
 {
-    return HeapAlloc(GetProcessHeap(), 0, cb);
+    return malloc(cb);
 }

 /*****************************************************
@ -241,7 +241,8 @@ LPVOID WINAPI AllocADsMem(DWORD cb)
 */
 BOOL WINAPI FreeADsMem(LPVOID pMem)
 {
-    return HeapFree(GetProcessHeap(), 0, pMem);
+    free(pMem);
+    return TRUE;
 }

 /*****************************************************
@ -249,7 +250,7 @@ BOOL WINAPI FreeADsMem(LPVOID pMem)
 */
 LPVOID WINAPI ReallocADsMem(LPVOID pOldMem, DWORD cbOld, DWORD cbNew)
 {
-    return HeapReAlloc(GetProcessHeap(), 0, pOldMem, cbNew);
+    return realloc(pOldMem, cbNew);
 }

 /*****************************************************
@ -257,18 +258,8 @@ LPVOID WINAPI ReallocADsMem(LPVOID pOldMem, DWORD cbOld, DWORD cbNew)
 */
 LPWSTR WINAPI AllocADsStr(LPWSTR pStr)
 {
-    LPWSTR ret;
-    SIZE_T len;
-
    TRACE("(%p)\n", pStr);
-
-    if (!pStr) return NULL;
-
-    len = (wcslen(pStr) + 1) * sizeof(WCHAR);
-    ret = AllocADsMem(len);
-    if (ret) memcpy(ret, pStr, len);
-
-    return ret;
+    return wcsdup(pStr);
 }

 /*****************************************************
--- a/dlls/activeds/pathname.c
+++ b/dlls/activeds/pathname.c
@ -28,7 +28,6 @@
 #include "iads.h"
 #include "adserr.h"

-#include "wine/heap.h"
 #include "wine/debug.h"

 WINE_DEFAULT_DEBUG_CHANNEL(activeds);
@ -84,7 +83,7 @@ static ULONG WINAPI path_Release(IADsPathname *iface)
        SysFreeString(path->provider);
        SysFreeString(path->server);
        SysFreeString(path->dn);
-        heap_free(path);
+        free(path);
    }

    return ref;
@ -136,7 +135,10 @@ static HRESULT parse_path(BSTR path, BSTR *provider, BSTR *server, BSTR *dn)
    if (!*p) return S_OK;

    if (*p++ != '/' || *p++ != '/' || !*p)
+    {
+        SysFreeString(*provider);
        return E_ADS_BAD_PATHNAME;
+    }

    p_server = p;
    server_len = 0;
@ -145,7 +147,11 @@ static HRESULT parse_path(BSTR path, BSTR *provider, BSTR *server, BSTR *dn)
        p++;
        server_len++;
    }
-    if (server_len == 0) return E_ADS_BAD_PATHNAME;
+    if (server_len == 0)
+    {
+        SysFreeString(*provider);
+        return E_ADS_BAD_PATHNAME;
+    }

    *server = SysAllocStringLen(p_server, server_len);
    if (!*server)
@ -409,7 +415,7 @@ static HRESULT Pathname_create(REFIID riid, void **obj)
    Pathname *path;
    HRESULT hr;

-    path = heap_alloc(sizeof(*path));
+    path = malloc(sizeof(*path));
    if (!path) return E_OUTOFMEMORY;

    path->IADsPathname_iface.lpVtbl = &IADsPathname_vtbl;
@ -482,7 +488,7 @@ static ULONG WINAPI factory_Release(IClassFactory *iface)
    TRACE("(%p) ref %lu\n", iface, ref);

    if (!ref)
-        heap_free(factory);
+        free(factory);

    return ref;
 }
@ -521,7 +527,7 @@ static HRESULT factory_constructor(const struct class_info *info, REFIID riid, v
    class_factory *factory;
    HRESULT hr;

-    factory = heap_alloc(sizeof(*factory));
+    factory = malloc(sizeof(*factory));
    if (!factory) return E_OUTOFMEMORY;

    factory->IClassFactory_iface.lpVtbl = &factory_vtbl;
--- a/dlls/activeds/tests/Makefile.in
+++ b/dlls/activeds/tests/Makefile.in
@ -1,5 +1,5 @@
 TESTDLL   = activeds.dll
 IMPORTS   = ole32 oleaut32 activeds

-C_SRCS = \
+SOURCES = \
 	activeds.c
--- a/dlls/actxprxy/Makefile.in
+++ b/dlls/actxprxy/Makefile.in
@ -1,10 +1,7 @@
 MODULE    = actxprxy.dll
 IMPORTS   = uuid oleaut32 ole32 rpcrt4

-C_SRCS = \
-	usrmarshal.c
-
-IDL_SRCS = \
+SOURCES = \
 	actxprxy_activscp.idl \
 	actxprxy_comcat.idl \
 	actxprxy_docobj.idl \
@ -16,6 +13,7 @@ IDL_SRCS = \
 	actxprxy_servprov.idl \
 	actxprxy_shldisp.idl \
 	actxprxy_shobjidl.idl \
-	actxprxy_urlhist.idl
+	actxprxy_urlhist.idl \
+	usrmarshal.c

 dlldata_EXTRADEFS = -DWINE_REGISTER_DLL -DPROXY_DELEGATION
--- a/dlls/actxprxy/actxprxy_activscp.idl
+++ b/dlls/actxprxy/actxprxy_activscp.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_comcat.idl
+++ b/dlls/actxprxy/actxprxy_comcat.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_docobj.idl
+++ b/dlls/actxprxy/actxprxy_docobj.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_hlink.idl
+++ b/dlls/actxprxy/actxprxy_hlink.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_htiface.idl
+++ b/dlls/actxprxy/actxprxy_htiface.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_htiframe.idl
+++ b/dlls/actxprxy/actxprxy_htiframe.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_objsafe.idl
+++ b/dlls/actxprxy/actxprxy_objsafe.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_ocmm.idl
+++ b/dlls/actxprxy/actxprxy_ocmm.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_servprov.idl
+++ b/dlls/actxprxy/actxprxy_servprov.idl
@ -7,4 +7,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_shldisp.idl
+++ b/dlls/actxprxy/actxprxy_shldisp.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_shobjidl.idl
+++ b/dlls/actxprxy/actxprxy_shobjidl.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/actxprxy/actxprxy_urlhist.idl
+++ b/dlls/actxprxy/actxprxy_urlhist.idl
@ -27,4 +27,4 @@
    threading(both),
    uuid(b8da6310-e19b-11d0-933c-00a0c90dcaa9)  /* IActiveScriptStats */
 ]
-coclass PSFactoryBuffer { interface IFactoryBuffer; }
+coclass PSFactoryBuffer { interface IPSFactoryBuffer; }
--- a/dlls/adsldp/Makefile.in
+++ b/dlls/adsldp/Makefile.in
@ -4,12 +4,9 @@ DELAYIMPORTS = netapi32 wldap32

 EXTRADLLFLAGS = -Wb,--prefer-native

-C_SRCS = \
+SOURCES = \
 	adsldp.c \
+	adsldp.idl \
 	ldap.c \
+	rsrc.rc \
 	schema.c
-
-IDL_SRCS = \
-	adsldp.idl
-
-RC_SRCS = rsrc.rc
--- a/dlls/adsldp/adsldp.c
+++ b/dlls/adsldp/adsldp.c
@ -21,8 +21,6 @@
 #include <stdarg.h>

 #define COBJMACROS
-#define NONAMELESSUNION
-
 #include "windef.h"
 #include "winbase.h"
 #include "initguid.h"
@ -1155,13 +1153,13 @@ static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_S
                break;
            }

-            switch (prefs[i].vValue.u.Integer)
+            switch (prefs[i].vValue.Integer)
            {
            case ADS_SCOPE_BASE:
            case ADS_SCOPE_ONELEVEL:
            case ADS_SCOPE_SUBTREE:
-                TRACE("SEARCH_SCOPE: %ld\n", prefs[i].vValue.u.Integer);
-                ldap->search.scope = prefs[i].vValue.u.Integer;
+                TRACE("SEARCH_SCOPE: %ld\n", prefs[i].vValue.Integer);
+                ldap->search.scope = prefs[i].vValue.Integer;
                prefs[i].dwStatus = ADS_STATUS_S_OK;
                break;

@ -1186,8 +1184,8 @@ static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_S
                break;
            }

-            TRACE("SECURITY_MASK: %08lx\n", prefs[i].vValue.u.Integer);
-            security_mask = prefs[i].vValue.u.Integer;
+            TRACE("SECURITY_MASK: %08lx\n", prefs[i].vValue.Integer);
+            security_mask = prefs[i].vValue.Integer;
            if (!security_mask)
                security_mask = ADS_SECURITY_INFO_OWNER;

@ -1229,8 +1227,8 @@ static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_S
                break;
            }

-            TRACE("PAGESIZE: %ld\n", prefs[i].vValue.u.Integer);
-            ldap->search.pagesize = prefs[i].vValue.u.Integer;
+            TRACE("PAGESIZE: %ld\n", prefs[i].vValue.Integer);
+            ldap->search.pagesize = prefs[i].vValue.Integer;
            prefs[i].dwStatus = ADS_STATUS_S_OK;
            break;

@ -1242,8 +1240,8 @@ static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_S
                break;
            }

-            TRACE("CACHE_RESULTS: %ld\n", prefs[i].vValue.u.Boolean);
-            ldap->search.cache_results = prefs[i].vValue.u.Boolean;
+            TRACE("CACHE_RESULTS: %ld\n", prefs[i].vValue.Boolean);
+            ldap->search.cache_results = prefs[i].vValue.Boolean;
            prefs[i].dwStatus = ADS_STATUS_S_OK;
            break;

@ -1255,8 +1253,8 @@ static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_S
                break;
            }

-            TRACE("ATTRIBTYPES_ONLY: %ld\n", prefs[i].vValue.u.Boolean);
-            ldap->search.attribtypes_only = prefs[i].vValue.u.Boolean;
+            TRACE("ATTRIBTYPES_ONLY: %ld\n", prefs[i].vValue.Boolean);
+            ldap->search.attribtypes_only = prefs[i].vValue.Boolean;
            prefs[i].dwStatus = ADS_STATUS_S_OK;
            break;

@ -1268,8 +1266,8 @@ static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_S
                break;
            }

-            TRACE("TOMBSTONE: %ld\n", prefs[i].vValue.u.Boolean);
-            ldap->search.tombstone = prefs[i].vValue.u.Boolean;
+            TRACE("TOMBSTONE: %ld\n", prefs[i].vValue.Boolean);
+            ldap->search.tombstone = prefs[i].vValue.Boolean;
            prefs[i].dwStatus = ADS_STATUS_S_OK;
            break;

@ -1281,8 +1279,8 @@ static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_S
                break;
            }

-            TRACE("SIZE_LIMIT: %ld\n", prefs[i].vValue.u.Integer);
-            ldap->search.size_limit = prefs[i].vValue.u.Integer;
+            TRACE("SIZE_LIMIT: %ld\n", prefs[i].vValue.Integer);
+            ldap->search.size_limit = prefs[i].vValue.Integer;
            prefs[i].dwStatus = ADS_STATUS_S_OK;
            break;

@ -1542,7 +1540,7 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
        {
            TRACE("=> %s\n", debugstr_w(values[i]));
            col->pADsValues[i].dwType = type;
-            col->pADsValues[i].u.CaseIgnoreString = values[i];
+            col->pADsValues[i].CaseIgnoreString = values[i];
        }

        col->hReserved = values;
@ -1568,15 +1566,15 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
            col->pADsValues[i].dwType = type;

            if (!wcsicmp(values[i], L"TRUE"))
-                col->pADsValues[i].u.Boolean = 1;
+                col->pADsValues[i].Boolean = 1;
            else if (!wcsicmp(values[i], L"FALSE"))
-                col->pADsValues[i].u.Boolean = 0;
+                col->pADsValues[i].Boolean = 0;
            else
            {
                FIXME("not recognized boolean value %s\n", debugstr_w(values[i]));
-                col->pADsValues[i].u.Boolean = 0;
+                col->pADsValues[i].Boolean = 0;
            }
-            TRACE("%s => %ld\n", debugstr_w(values[i]), col->pADsValues[i].u.Boolean);
+            TRACE("%s => %ld\n", debugstr_w(values[i]), col->pADsValues[i].Boolean);
        }

        ldap_value_freeW(values);
@ -1605,13 +1603,13 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex

            if (type == ADSTYPE_LARGE_INTEGER)
            {
-                col->pADsValues[i].u.LargeInteger.QuadPart = _atoi64(values[i]->bv_val);
-                TRACE("%s => %s\n", debugstr_an(values[i]->bv_val, values[i]->bv_len), wine_dbgstr_longlong(col->pADsValues[i].u.LargeInteger.QuadPart));
+                col->pADsValues[i].LargeInteger.QuadPart = _atoi64(values[i]->bv_val);
+                TRACE("%s => %s\n", debugstr_an(values[i]->bv_val, values[i]->bv_len), wine_dbgstr_longlong(col->pADsValues[i].LargeInteger.QuadPart));
            }
            else
            {
-                col->pADsValues[i].u.Integer = atol(values[i]->bv_val);
-                TRACE("%s => %ld\n", debugstr_an(values[i]->bv_val, values[i]->bv_len), col->pADsValues[i].u.Integer);
+                col->pADsValues[i].Integer = atol(values[i]->bv_val);
+                TRACE("%s => %ld\n", debugstr_an(values[i]->bv_val, values[i]->bv_len), col->pADsValues[i].Integer);
            }
        }

@ -1639,8 +1637,8 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
        {
            TRACE("=> %s\n", debugstr_an(values[i]->bv_val, values[i]->bv_len));
            col->pADsValues[i].dwType = type;
-            col->pADsValues[i].u.OctetString.dwLength = values[i]->bv_len;
-            col->pADsValues[i].u.OctetString.lpValue = (BYTE *)values[i]->bv_val;
+            col->pADsValues[i].OctetString.dwLength = values[i]->bv_len;
+            col->pADsValues[i].OctetString.lpValue = (BYTE *)values[i]->bv_val;
        }

        col->hReserved = values;
@ -1666,12 +1664,12 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
            col->pADsValues[i].dwType = type;
            if (values[i]->bv_len < 14 ||
                _snscanf_l(values[i]->bv_val, values[i]->bv_len, "%04hu%02hu%02hu%02hu%02hu%02hu", NULL,
-                           &col->pADsValues[i].u.UTCTime.wYear, &col->pADsValues[i].u.UTCTime.wMonth,
-                           &col->pADsValues[i].u.UTCTime.wDay, &col->pADsValues[i].u.UTCTime.wHour,
-                           &col->pADsValues[i].u.UTCTime.wMinute, &col->pADsValues[i].u.UTCTime.wSecond) != 6)
+                           &col->pADsValues[i].UTCTime.wYear, &col->pADsValues[i].UTCTime.wMonth,
+                           &col->pADsValues[i].UTCTime.wDay, &col->pADsValues[i].UTCTime.wHour,
+                           &col->pADsValues[i].UTCTime.wMinute, &col->pADsValues[i].UTCTime.wSecond) != 6)
            {
                FIXME("not recognized UTCTime: %s\n", debugstr_an(values[i]->bv_val, values[i]->bv_len));
-                memset(&col->pADsValues[i].u.UTCTime, 0, sizeof(col->pADsValues[i].u.UTCTime));
+                memset(&col->pADsValues[i].UTCTime, 0, sizeof(col->pADsValues[i].UTCTime));
                continue;
            }

@ -1680,9 +1678,9 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
                    FIXME("not handled time zone: %s\n", debugstr_an(values[i]->bv_val + 14, values[i]->bv_len - 14));

            TRACE("%s => %02u.%02u.%04u %02u:%02u:%02u\n", debugstr_an(values[i]->bv_val, values[i]->bv_len),
-                  col->pADsValues[i].u.UTCTime.wDay, col->pADsValues[i].u.UTCTime.wMonth,
-                  col->pADsValues[i].u.UTCTime.wYear, col->pADsValues[i].u.UTCTime.wHour,
-                  col->pADsValues[i].u.UTCTime.wMinute, col->pADsValues[i].u.UTCTime.wSecond);
+                  col->pADsValues[i].UTCTime.wDay, col->pADsValues[i].UTCTime.wMonth,
+                  col->pADsValues[i].UTCTime.wYear, col->pADsValues[i].UTCTime.wHour,
+                  col->pADsValues[i].UTCTime.wMinute, col->pADsValues[i].UTCTime.wSecond);
        }

        ldap_value_free_len(values);
@ -1708,7 +1706,7 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
            return E_ADS_COLUMN_NOT_SET;
        count = ldap_count_valuesW(values);

-        col->pADsValues = calloc(count, sizeof(col->pADsValues[0]) + sizeof(col->pADsValues[0].u.pDNWithBinary[0]));
+        col->pADsValues = calloc(count, sizeof(col->pADsValues[0]) + sizeof(col->pADsValues[0].pDNWithBinary[0]));
        if (!col->pADsValues)
        {
            ldap_value_freeW(values);
@ -1723,19 +1721,19 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
            DWORD n;

            col->pADsValues[i].dwType = type;
-            col->pADsValues[i].u.pDNWithBinary = dnb++;
+            col->pADsValues[i].pDNWithBinary = dnb++;

            if ((p[0] != 'b' && p[0] != 'B') || p[1] != ':')
                FIXME("wrong DN with binary tag '%c%c'\n", p[0], p[1]);
            p += 2;

-            col->pADsValues[i].u.pDNWithBinary->dwLength = wcstol(p, &p, 10) / 2;
+            col->pADsValues[i].pDNWithBinary->dwLength = wcstol(p, &p, 10) / 2;
            if (*p != ':')
                FIXME("wrong DN with binary separator '%c'\n", *p);
            p++;
-            col->pADsValues[i].u.pDNWithBinary->lpBinaryValue = (BYTE *)p;
+            col->pADsValues[i].pDNWithBinary->lpBinaryValue = (BYTE *)p;
            /* decode values in-place */
-            for (n = 0; n < col->pADsValues[i].u.pDNWithBinary->dwLength; n++, p += 2)
+            for (n = 0; n < col->pADsValues[i].pDNWithBinary->dwLength; n++, p += 2)
            {
                BYTE b;

@ -1747,16 +1745,16 @@ static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_contex
                }

                b = (hex2bin[p[0]] << 4) | hex2bin[p[1]];
-                col->pADsValues[i].u.pDNWithBinary->lpBinaryValue[n] = b;
+                col->pADsValues[i].pDNWithBinary->lpBinaryValue[n] = b;
            }
            if (*p != ':')
                FIXME("wrong DN with binary separator '%c'\n", *p);
-            col->pADsValues[i].u.pDNWithBinary->pszDNString = p + 1;
+            col->pADsValues[i].pDNWithBinary->pszDNString = p + 1;

            TRACE("%s => %lu,%s,%s\n", debugstr_w(values[i]),
-                  col->pADsValues[i].u.pDNWithBinary->dwLength,
-                  debugstr_an((char *)col->pADsValues[i].u.pDNWithBinary->lpBinaryValue, col->pADsValues[i].u.pDNWithBinary->dwLength),
-                  debugstr_w(col->pADsValues[i].u.pDNWithBinary->pszDNString));
+                  col->pADsValues[i].pDNWithBinary->dwLength,
+                  debugstr_an((char *)col->pADsValues[i].pDNWithBinary->lpBinaryValue, col->pADsValues[i].pDNWithBinary->dwLength),
+                  debugstr_w(col->pADsValues[i].pDNWithBinary->pszDNString));
        }

        col->hReserved = values;
@ -1799,24 +1797,24 @@ static HRESULT WINAPI search_GetColumn(IDirectorySearch *iface, ADS_SEARCH_HANDL
        count = sizeof(L"LDAP://") + (wcslen(ldap->host) + 1 /* '/' */) * sizeof(WCHAR);
        if (dn) count += wcslen(dn) * sizeof(WCHAR);

-        col->pADsValues[0].u.CaseIgnoreString = malloc(count);
-        if (!col->pADsValues[0].u.CaseIgnoreString)
+        col->pADsValues[0].CaseIgnoreString = malloc(count);
+        if (!col->pADsValues[0].CaseIgnoreString)
        {
            hr = E_OUTOFMEMORY;
            goto exit;
        }

-        wcscpy(col->pADsValues[0].u.CaseIgnoreString, L"LDAP://");
-        wcscat(col->pADsValues[0].u.CaseIgnoreString, ldap->host);
-        wcscat(col->pADsValues[0].u.CaseIgnoreString, L"/");
-        if (dn) wcscat(col->pADsValues[0].u.CaseIgnoreString, dn);
+        wcscpy(col->pADsValues[0].CaseIgnoreString, L"LDAP://");
+        wcscat(col->pADsValues[0].CaseIgnoreString, ldap->host);
+        wcscat(col->pADsValues[0].CaseIgnoreString, L"/");
+        if (dn) wcscat(col->pADsValues[0].CaseIgnoreString, dn);
        col->pADsValues[0].dwType = ADSTYPE_CASE_IGNORE_STRING;
        col->dwADsType = ADSTYPE_CASE_IGNORE_STRING;
        col->dwNumValues = 1;
        col->pszAttrName = wcsdup(name);
        col->hReserved = NULL;

-        TRACE("=> %s\n", debugstr_w(col->pADsValues[0].u.CaseIgnoreString));
+        TRACE("=> %s\n", debugstr_w(col->pADsValues[0].CaseIgnoreString));
        hr = S_OK;
 exit:
        ldap_memfreeW(dn);
@ -1833,7 +1831,7 @@ static HRESULT WINAPI search_FreeColumn(IDirectorySearch *iface, PADS_SEARCH_COL
    if (!col) return E_ADS_BAD_PARAMETER;

    if (!wcsicmp(col->pszAttrName, L"ADsPath"))
-        free(col->pADsValues[0].u.CaseIgnoreString);
+        free(col->pADsValues[0].CaseIgnoreString);
    free(col->pADsValues);
    free(col->pszAttrName);

--- a/dlls/adsldp/adsldp_private.h
+++ b/dlls/adsldp/adsldp_private.h
@ -19,8 +19,6 @@
 #ifndef _ADSLDP_PRIVATE_H
 #define _ADSLDP_PRIVATE_H

-#include "wine/heap.h"
-
 static inline LPWSTR strnUtoW( LPCSTR str, DWORD inlen, DWORD *outlen )
 {
    LPWSTR ret = NULL;
@ -28,7 +26,7 @@ static inline LPWSTR strnUtoW( LPCSTR str, DWORD inlen, DWORD *outlen )
    if (str)
    {
        DWORD len = MultiByteToWideChar( CP_UTF8, 0, str, inlen, NULL, 0 );
-        if ((ret = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+        if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
        {
            MultiByteToWideChar( CP_UTF8, 0, str, inlen, ret, len );
            ret[len] = 0;
@ -47,9 +45,9 @@ struct attribute_type
    int single_value;
 };

-DWORD map_ldap_error(DWORD) DECLSPEC_HIDDEN;
-struct attribute_type *load_schema(LDAP *ld, ULONG *, ULONG *) DECLSPEC_HIDDEN;
-ADSTYPEENUM get_schema_type(const WCHAR *, const struct attribute_type *, ULONG, ULONG) DECLSPEC_HIDDEN;
-void free_attribute_types(struct attribute_type *, ULONG) DECLSPEC_HIDDEN;
+DWORD map_ldap_error(DWORD);
+struct attribute_type *load_schema(LDAP *ld, ULONG *, ULONG *);
+ADSTYPEENUM get_schema_type(const WCHAR *, const struct attribute_type *, ULONG, ULONG);
+void free_attribute_types(struct attribute_type *, ULONG);

 #endif
--- a/dlls/adsldp/schema.c
+++ b/dlls/adsldp/schema.c
@ -25,7 +25,6 @@

 #include "adsldp_private.h"

-#include "wine/heap.h"
 #include "wine/debug.h"

 WINE_DEFAULT_DEBUG_CHANNEL(adsldp);
@ -116,9 +115,9 @@ ADSTYPEENUM get_schema_type(const WCHAR *name, const struct attribute_type *at,

 static void free_attribute_type(struct attribute_type *at)
 {
-    heap_free(at->oid);
-    heap_free(at->name);
-    heap_free(at->syntax);
+    free(at->oid);
+    free(at->name);
+    free(at->syntax);
 }

 void free_attribute_types(struct attribute_type *at, ULONG count)
@ -128,7 +127,7 @@ void free_attribute_types(struct attribute_type *at, ULONG count)
    for (i = 0; i < count; i++)
        free_attribute_type(&at[i]);

-    heap_free(at);
+    free(at);
 }

 static BOOL is_space(WCHAR c)
@ -156,7 +155,7 @@ static WCHAR *parse_oid(WCHAR **str)
    }

    count = end - p;
-    oid = heap_alloc((count + 1) * sizeof(WCHAR));
+    oid = malloc((count + 1) * sizeof(WCHAR));
    if (!oid) return NULL;

    memcpy(oid, p, count * sizeof(WCHAR));
@ -202,17 +201,14 @@ static WCHAR *parse_name(WCHAR **str, ULONG *name_count)

            count = wcslen(tmp_name);

-            if (!name)
-                new_name = heap_alloc((count + 1) * sizeof(WCHAR));
-            else
-                new_name = heap_realloc(name, (total_count + count + 1) * sizeof(WCHAR));
+            new_name = realloc(name, (total_count + count + 1) * sizeof(WCHAR));

            if (!new_name) break;

            memcpy(new_name + total_count, tmp_name, (count + 1) * sizeof(WCHAR));

            name = new_name;
-            heap_free(tmp_name);
+            free(tmp_name);
            total_count += count + 1;

            *name_count += 1;
@ -221,7 +217,7 @@ static WCHAR *parse_name(WCHAR **str, ULONG *name_count)

        *str = *p ? p + 1 : p;

-        heap_free(name);
+        free(name);
        return NULL;
    }

@ -236,7 +232,7 @@ static WCHAR *parse_name(WCHAR **str, ULONG *name_count)
    if (!end) return NULL;

    count = end - p;
-    name = heap_alloc((count + 1) * sizeof(WCHAR));
+    name = malloc((count + 1) * sizeof(WCHAR));
    if (!name) return NULL;

    memcpy(name, p, count * sizeof(WCHAR));
@ -400,7 +396,7 @@ struct attribute_type *load_schema(LDAP *ld, ULONG *at_single_count, ULONG *at_m
        {
            ULONG i, total = ldap_count_valuesW(types);

-            at = heap_alloc(total * sizeof(*at));
+            at = malloc(total * sizeof(*at));
            if (!at) goto exit;

            for (i = 0; i < total; i++)
--- a/dlls/adsldp/tests/Makefile.in
+++ b/dlls/adsldp/tests/Makefile.in
@ -1,6 +1,6 @@
 TESTDLL   = adsldp.dll
 IMPORTS   = ole32 oleaut32 secur32 advapi32 activeds uuid

-C_SRCS = \
+SOURCES = \
 	ldap.c \
 	sysinfo.c
--- a/dlls/adsldp/tests/ldap.c
+++ b/dlls/adsldp/tests/ldap.c
@ -37,6 +37,8 @@ DEFINE_GUID(CLSID_LDAP,0x228d9a81,0xc302,0x11cf,0x9a,0xa4,0x00,0xaa,0x00,0x4a,0x
 DEFINE_GUID(CLSID_LDAPNamespace,0x228d9a82,0xc302,0x11cf,0x9a,0xa4,0x00,0xaa,0x00,0x4a,0x56,0x91);
 DEFINE_OLEGUID(CLSID_PointerMoniker,0x306,0,0);

+static BOOL server_down;
+
 static const struct
 {
    const WCHAR *path;
@ -74,6 +76,8 @@ static void test_LDAP(void)
    BSTR path, user, password;
    int i;

+    if (server_down) return;
+
    hr = CoCreateInstance(&CLSID_LDAPNamespace, 0, CLSCTX_INPROC_SERVER, &IID_IADs, (void **)&ads);
    ok(hr == S_OK, "got %#lx\n", hr);
    IADs_Release(ads);
@ -99,6 +103,7 @@ static void test_LDAP(void)
        {
            SysFreeString(path);
            skip("server is down\n");
+            server_down = TRUE;
            break;
        }
        ok(hr == test[i].hr || hr == test[i].hr_ads_open, "%d: got %#lx, expected %#lx\n", i, hr, test[i].hr);
@ -110,6 +115,7 @@ static void test_LDAP(void)
        {
            SysFreeString(path);
            skip("server is down\n");
+            server_down = TRUE;
            break;
        }
        ok(hr == test[i].hr || hr == test[i].hr_ads_get, "%d: got %#lx, expected %#lx\n", i, hr, test[i].hr);
@ -121,6 +127,7 @@ static void test_LDAP(void)
        {
            SysFreeString(path);
            skip("server is down\n");
+            server_down = TRUE;
            break;
        }
        ok(hr == test[i].hr || hr == test[i].hr_ads_get, "%d: got %#lx, expected %#lx\n", i, hr, test[i].hr);
@ -149,6 +156,8 @@ static void test_ParseDisplayName(void)
    ULONG count;
    int i;

+    if (server_down) return;
+
    hr = CoCreateInstance(&CLSID_LDAP, 0, CLSCTX_INPROC_SERVER, &IID_IParseDisplayName, (void **)&parse);
    ok(hr == S_OK, "got %#lx\n", hr);
    IParseDisplayName_Release(parse);
@ -172,6 +181,7 @@ static void test_ParseDisplayName(void)
        {
            SysFreeString(path);
            skip("server is down\n");
+            server_down = TRUE;
            break;
        }
        ok(hr == test[i].hr || hr == test[i].hr_ads_open, "%d: got %#lx, expected %#lx\n", i, hr, test[i].hr);
@ -193,6 +203,7 @@ static void test_ParseDisplayName(void)
        if (hr == HRESULT_FROM_WIN32(ERROR_DS_SERVER_DOWN))
        {
            skip("server is down\n");
+            server_down = TRUE;
            break;
        }
        todo_wine_if(i == 0 || i == 1 || i == 11 || i == 12)
@ -237,12 +248,15 @@ static void do_search(const struct search *s)
    LPWSTR name;
    const struct result *res;

+    if (server_down) return;
+
    trace("search DN %s\n", wine_dbgstr_w(s->dn));

    hr = ADsGetObject(s->dn, &IID_IDirectorySearch, (void **)&ds);
    if (hr == HRESULT_FROM_WIN32(ERROR_DS_SERVER_DOWN))
    {
        skip("server is down\n");
+        server_down = TRUE;
        return;
    }
    ok(hr == S_OK, "got %#lx\n", hr);
@ -296,8 +310,6 @@ static void do_search(const struct search *s)
                   "expected %s, got %s\n", wine_dbgstr_w(res->values[i]), wine_dbgstr_w(col.pADsValues[i].CaseIgnoreString));
            }

-            ok(!res->values[i], "expected extra value %s\n", wine_dbgstr_w(res->values[i]));
-
            IDirectorySearch_FreeColumn(ds, &col);
            FreeADsMem(name);
            res++;
@ -363,6 +375,8 @@ static void test_DirectorySearch(void)
    ADS_SEARCH_COLUMN col;
    LPWSTR name;

+    if (server_down) return;
+
    hr = ADsGetObject(L"LDAP:", &IID_IDirectorySearch, (void **)&ds);
    ok(hr == E_NOINTERFACE, "got %#lx\n", hr);

@ -370,6 +384,7 @@ static void test_DirectorySearch(void)
    if (hr == HRESULT_FROM_WIN32(ERROR_DS_SERVER_DOWN))
    {
        skip("server is down\n");
+        server_down = TRUE;
        return;
    }
    ok(hr == E_NOINTERFACE, "got %#lx\n", hr);
@ -378,6 +393,7 @@ static void test_DirectorySearch(void)
    if (hr == HRESULT_FROM_WIN32(ERROR_DS_SERVER_DOWN))
    {
        skip("server is down\n");
+        server_down = TRUE;
        return;
    }
    ok(hr == S_OK, "got %#lx\n", hr);
@ -492,10 +508,13 @@ static void test_DirectoryObject(void)
    ADS_SEARCH_HANDLE sh;
    ADS_SEARCH_COLUMN col;

+    if (server_down) return;
+
    hr = ADsGetObject(L"LDAP://ldap.forumsys.com/OU=scientists,DC=example,DC=com", &IID_IDirectoryObject, (void **)&dirobj);
    if (hr == HRESULT_FROM_WIN32(ERROR_DS_SERVER_DOWN))
    {
        skip("server is down\n");
+        server_down = TRUE;
        return;
    }
    ok(hr == S_OK, "got %#lx\n", hr);
--- a/dlls/advapi32/Makefile.in
+++ b/dlls/advapi32/Makefile.in
@ -2,9 +2,9 @@ EXTRADEFS = -D_ADVAPI32_
 MODULE    = advapi32.dll
 IMPORTLIB = advapi32
 IMPORTS   = kernelbase sechost msvcrt
-DELAYIMPORTS = rpcrt4
+DELAYIMPORTS = rpcrt4 user32

-C_SRCS = \
+SOURCES = \
 	advapi.c \
 	cred.c \
 	crypt.c \
@ -16,7 +16,5 @@ C_SRCS = \
 	registry.c \
 	security.c \
 	service.c \
+	version.rc \
 	wmi.c
-
-
-RC_SRCS = version.rc
--- a/dlls/advapi32/advapi.c
+++ b/dlls/advapi32/advapi.c
@ -252,9 +252,9 @@ BOOL WINAPI LogonUserA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassw
    ret = LogonUserW( usernameW, domainW, passwordW, dwLogonType, dwLogonProvider, phToken );

 done:
-    heap_free( usernameW );
-    heap_free( domainW );
-    heap_free( passwordW );
+    free( usernameW );
+    free( domainW );
+    free( passwordW );
    return ret;
 }

--- a/dlls/advapi32/advapi32.spec
+++ b/dlls/advapi32/advapi32.spec
@ -824,7 +824,7 @@
 # @ stub TreeResetNamedSecurityInfoA
@ stdcall TreeResetNamedSecurityInfoW(wstr long long ptr ptr ptr ptr long ptr long ptr)
 # @ stub TreeSetNamedSecurityInfoA
-# @ stub TreeSetNamedSecurityInfoW
+@ stdcall TreeSetNamedSecurityInfoW(wstr long long ptr ptr ptr ptr long ptr long ptr)
 # @ stub TrusteeAccessToObjectA
 # @ stub TrusteeAccessToObjectW
 # @ stub UninstallApplication
--- a/dlls/advapi32/advapi32_misc.h
+++ b/dlls/advapi32/advapi32_misc.h
@ -23,15 +23,14 @@
 #include "ntsecapi.h"
 #include "winsvc.h"
 #include "winnls.h"
-#include "wine/heap.h"

-const char * debugstr_sid(PSID sid) DECLSPEC_HIDDEN;
-BOOL ADVAPI_IsLocalComputer(LPCWSTR ServerName) DECLSPEC_HIDDEN;
-BOOL ADVAPI_GetComputerSid(PSID sid) DECLSPEC_HIDDEN;
+const char * debugstr_sid(PSID sid);
+BOOL ADVAPI_IsLocalComputer(LPCWSTR ServerName);
+BOOL ADVAPI_GetComputerSid(PSID sid);

-BOOL lookup_local_wellknown_name(const LSA_UNICODE_STRING*, PSID, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE, BOOL*) DECLSPEC_HIDDEN;
-BOOL lookup_local_user_name(const LSA_UNICODE_STRING*, PSID, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE, BOOL*) DECLSPEC_HIDDEN;
-const WCHAR *get_wellknown_privilege_name(const LUID *) DECLSPEC_HIDDEN;
+BOOL lookup_local_wellknown_name(const LSA_UNICODE_STRING*, PSID, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE, BOOL*);
+BOOL lookup_local_user_name(const LSA_UNICODE_STRING*, PSID, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE, BOOL*);
+const WCHAR *get_wellknown_privilege_name(const LUID *);

 /* memory allocation functions */

@ -41,7 +40,7 @@ static inline WCHAR *strdupAW( const char *src )
    if (src)
    {
        DWORD len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
-        if ((dst = heap_alloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
+        if ((dst = malloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
    }
    return dst;
 }
--- a/dlls/advapi32/cred.c
+++ b/dlls/advapi32/cred.c
@ -229,7 +229,7 @@ static DWORD write_credential_blob(HKEY hkey, LPCWSTR target_name, DWORD type,
    key.Length = key.MaximumLength = KEY_SIZE;
    key.Buffer = (unsigned char *)key_data;

-    encrypted_credential_blob = heap_alloc(credential_blob_size);
+    encrypted_credential_blob = malloc(credential_blob_size);
    if (!encrypted_credential_blob) return ERROR_OUTOFMEMORY;

    memcpy(encrypted_credential_blob, credential_blob, credential_blob_size);
@ -238,7 +238,7 @@ static DWORD write_credential_blob(HKEY hkey, LPCWSTR target_name, DWORD type,
    SystemFunction032(&data, &key);

    ret = RegSetValueExW(hkey, L"Password", 0, REG_BINARY, encrypted_credential_blob, credential_blob_size);
-    heap_free(encrypted_credential_blob);
+    free(encrypted_credential_blob);

    return ret;
 }
@ -320,7 +320,7 @@ static DWORD host_write_credential( const CREDENTIALW *credential, BOOL preserve
    size = sizeof(*cred) + (lstrlenW( credential->TargetName ) + lstrlenW( credential->UserName ) + 2) * sizeof(WCHAR);
    size += credential->CredentialBlobSize;
    if (credential->Comment) size += (lstrlenW( credential->Comment ) + 1) * sizeof(WCHAR);
-    if (!(cred = heap_alloc( size )))
+    if (!(cred = malloc( size )))
    {
        CloseHandle( mgr );
        return ERROR_OUTOFMEMORY;
@ -356,7 +356,7 @@ static DWORD host_write_credential( const CREDENTIALW *credential, BOOL preserve
    else cred->comment_size = 0;

    ret = DeviceIoControl( mgr, IOCTL_MOUNTMGR_WRITE_CREDENTIAL, cred, size, NULL, 0, NULL, NULL );
-    heap_free( cred );
+    free( cred );
    CloseHandle( mgr );

    return ret ? ERROR_SUCCESS : GetLastError();
@ -435,7 +435,7 @@ static LPWSTR get_key_name_for_target(LPCWSTR target_name, DWORD type)
        len += ARRAY_SIZE(L"DomPasswd: ");
    }

-    key_name = heap_alloc(len * sizeof(WCHAR));
+    key_name = malloc(len * sizeof(WCHAR));
    if (!key_name) return NULL;

    lstrcpyW(key_name, prefix);
@ -463,13 +463,13 @@ static BOOL registry_credential_matches_filter(HKEY hkeyCred, LPCWSTR filter)
    else if (type != REG_SZ)
        return FALSE;

-    target_name = heap_alloc(count);
+    target_name = malloc(count);
    if (!target_name)
        return FALSE;
    ret = RegQueryValueExW(hkeyCred, NULL, 0, &type, (LPVOID)target_name, &count);
    if (ret != ERROR_SUCCESS || type != REG_SZ)
    {
-        heap_free(target_name);
+        free(target_name);
        return FALSE;
    }

@ -481,7 +481,7 @@ static BOOL registry_credential_matches_filter(HKEY hkeyCred, LPCWSTR filter)
                         (p && !p[1] ? p - filter : -1), target_name,
                         (p && !p[1] ? p - filter : -1)) == CSTR_EQUAL;

-    heap_free(target_name);
+    free(target_name);
    return ret;
 }

@ -730,7 +730,7 @@ BOOL WINAPI CredDeleteA(LPCSTR TargetName, DWORD Type, DWORD Flags)
    }

    len = MultiByteToWideChar(CP_ACP, 0, TargetName, -1, NULL, 0);
-    TargetNameW = heap_alloc(len * sizeof(WCHAR));
+    TargetNameW = malloc(len * sizeof(WCHAR));
    if (!TargetNameW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
@ -740,7 +740,7 @@ BOOL WINAPI CredDeleteA(LPCSTR TargetName, DWORD Type, DWORD Flags)

    ret = CredDeleteW(TargetNameW, Type, Flags);

-    heap_free(TargetNameW);
+    free(TargetNameW);

    return ret;
 }
@ -758,7 +758,7 @@ static DWORD host_delete_credential( const WCHAR *targetname )
    if (mgr == INVALID_HANDLE_VALUE) return GetLastError();

    size = sizeof(*cred) + name_size;
-    if (!(cred = heap_alloc( size )))
+    if (!(cred = malloc( size )))
    {
        CloseHandle( mgr );
        return ERROR_OUTOFMEMORY;
@ -769,7 +769,7 @@ static DWORD host_delete_credential( const WCHAR *targetname )
    lstrcpyW( ptr, targetname );

    ret = DeviceIoControl( mgr, IOCTL_MOUNTMGR_DELETE_CREDENTIAL, cred, size, NULL, 0, NULL, NULL );
-    heap_free( cred );
+    free( cred );
    CloseHandle( mgr );

    return ret ? ERROR_SUCCESS : GetLastError();
@ -823,7 +823,7 @@ BOOL WINAPI CredDeleteW(LPCWSTR TargetName, DWORD Type, DWORD Flags)

    key_name = get_key_name_for_target(TargetName, Type);
    ret = RegDeleteKeyW(hkeyMgr, key_name);
-    heap_free(key_name);
+    free(key_name);
    RegCloseKey(hkeyMgr);
    if (ret != ERROR_SUCCESS)
    {
@ -852,7 +852,7 @@ BOOL WINAPI CredEnumerateA(LPCSTR Filter, DWORD Flags, DWORD *Count,
    if (Filter)
    {
        len = MultiByteToWideChar(CP_ACP, 0, Filter, -1, NULL, 0);
-        FilterW = heap_alloc(len * sizeof(WCHAR));
+        FilterW = malloc(len * sizeof(WCHAR));
        if (!FilterW)
        {
            SetLastError(ERROR_OUTOFMEMORY);
@ -865,16 +865,16 @@ BOOL WINAPI CredEnumerateA(LPCSTR Filter, DWORD Flags, DWORD *Count,

    if (!CredEnumerateW(FilterW, Flags, Count, &CredentialsW))
    {
-        heap_free(FilterW);
+        free(FilterW);
        return FALSE;
    }
-    heap_free(FilterW);
+    free(FilterW);

    len = *Count * sizeof(PCREDENTIALA);
    for (i = 0; i < *Count; i++)
        len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);

-    *Credentials = heap_alloc(len);
+    *Credentials = malloc(len);
    if (!*Credentials)
    {
        CredFree(CredentialsW);
@ -917,7 +917,7 @@ static DWORD host_enumerate_credentials( const WCHAR *filter, CREDENTIALW **cred
    if (mgr == INVALID_HANDLE_VALUE) return GetLastError();

    size = FIELD_OFFSET( struct mountmgr_credential_list, creds[CRED_LIST_COUNT] ) + filter_size + CRED_DATA_SIZE;
-    if (!(list = heap_alloc( size )))
+    if (!(list = malloc( size )))
    {
        CloseHandle( mgr );
        return ERROR_OUTOFMEMORY;
@ -934,7 +934,7 @@ static DWORD host_enumerate_credentials( const WCHAR *filter, CREDENTIALW **cred
        if ((ret = GetLastError()) != ERROR_MORE_DATA) goto done;

        size = list->size + filter_size;
-        if (!(tmp = heap_realloc( list, size )))
+        if (!(tmp = realloc( list, size )))
        {
            ret = ERROR_OUTOFMEMORY;
            goto done;
@ -994,7 +994,7 @@ static DWORD host_enumerate_credentials( const WCHAR *filter, CREDENTIALW **cred
    ret = ERROR_SUCCESS;

 done:
-    heap_free( list );
+    free( list );
    CloseHandle( mgr );
    return ret;
 }
@ -1044,7 +1044,7 @@ BOOL WINAPI CredEnumerateW(LPCWSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIA
        return FALSE;
    }

-    target_name = heap_alloc((target_name_len+1)*sizeof(WCHAR));
+    target_name = malloc((target_name_len + 1) * sizeof(WCHAR));
    if (!target_name)
    {
        RegCloseKey(hkeyMgr);
@ -1065,7 +1065,7 @@ BOOL WINAPI CredEnumerateW(LPCWSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIA
        ret = ERROR_NOT_FOUND;
    if (ret != ERROR_SUCCESS)
    {
-        heap_free(target_name);
+        free(target_name);
        RegCloseKey(hkeyMgr);
        SetLastError(ret);
        return FALSE;
@ -1074,7 +1074,7 @@ BOOL WINAPI CredEnumerateW(LPCWSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIA

    if (ret == ERROR_SUCCESS)
    {
-        buffer = heap_alloc(len);
+        buffer = malloc(len);
        *Credentials = (PCREDENTIALW *)buffer;
        if (buffer)
        {
@ -1091,7 +1091,7 @@ BOOL WINAPI CredEnumerateW(LPCWSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIA
        else ret = ERROR_OUTOFMEMORY;
    }

-    heap_free(target_name);
+    free(target_name);
    RegCloseKey(hkeyMgr);

    if (ret != ERROR_SUCCESS)
@ -1107,7 +1107,7 @@ BOOL WINAPI CredEnumerateW(LPCWSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIA
 */
 VOID WINAPI CredFree(PVOID Buffer)
 {
-    heap_free(Buffer);
+    free(Buffer);
 }

 /******************************************************************************
@ -1128,7 +1128,7 @@ BOOL WINAPI CredReadA(LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *
    }

    len = MultiByteToWideChar(CP_ACP, 0, TargetName, -1, NULL, 0);
-    TargetNameW = heap_alloc(len * sizeof(WCHAR));
+    TargetNameW = malloc(len * sizeof(WCHAR));
    if (!TargetNameW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
@ -1138,13 +1138,13 @@ BOOL WINAPI CredReadA(LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *

    if (!CredReadW(TargetNameW, Type, Flags, &CredentialW))
    {
-        heap_free(TargetNameW);
+        free(TargetNameW);
        return FALSE;
    }
-    heap_free(TargetNameW);
+    free(TargetNameW);

    len = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, NULL, 0);
-    *Credential = heap_alloc(len);
+    *Credential = malloc(len);
    if (!*Credential)
    {
        SetLastError(ERROR_OUTOFMEMORY);
@ -1170,7 +1170,7 @@ static DWORD host_read_credential( const WCHAR *targetname, CREDENTIALW **ret_cr
    if (mgr == INVALID_HANDLE_VALUE) return GetLastError();

    size_in = sizeof(*cred_in) + size_name;
-    if (!(cred_in = heap_alloc( size_in )))
+    if (!(cred_in = malloc( size_in )))
    {
        CloseHandle( mgr );
        return ERROR_OUTOFMEMORY;
@ -1181,14 +1181,14 @@ static DWORD host_read_credential( const WCHAR *targetname, CREDENTIALW **ret_cr
    lstrcpyW( ptr, targetname );

    size_out = 256;
-    if (!(cred_out = heap_alloc( size_out ))) goto done;
+    if (!(cred_out = malloc( size_out ))) goto done;

    for (;;)
    {
        ret = DeviceIoControl( mgr, IOCTL_MOUNTMGR_READ_CREDENTIAL, cred_in, size_in, cred_out, size_out, NULL, NULL );
        if (ret || (err = GetLastError()) != ERROR_MORE_DATA) break;
        size_out *= 2;
-        if (!(tmp = heap_realloc( cred_out, size_out ))) goto done;
+        if (!(tmp = realloc( cred_out, size_out ))) goto done;
        cred_out = tmp;
    }

@ -1198,7 +1198,7 @@ static DWORD host_read_credential( const WCHAR *targetname, CREDENTIALW **ret_cr
        DWORD size = sizeof(*credential) + cred_out->targetname_size + cred_out->username_size + cred_out->comment_size +
                     cred_out->blob_size;

-        if (!(credential = heap_alloc_zero( size )))
+        if (!(credential = calloc( 1, size )))
        {
            err = ERROR_OUTOFMEMORY;
            goto done;
@ -1231,8 +1231,8 @@ static DWORD host_read_credential( const WCHAR *targetname, CREDENTIALW **ret_cr
    }

 done:
-    heap_free( cred_in );
-    heap_free( cred_out );
+    free( cred_in );
+    free( cred_out );
    CloseHandle( mgr );
    return err;
 }
@ -1300,7 +1300,7 @@ BOOL WINAPI CredReadW(LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALW

    key_name = get_key_name_for_target(TargetName, Type);
    ret = RegOpenKeyExW(hkeyMgr, key_name, 0, KEY_QUERY_VALUE, &hkeyCred);
-    heap_free(key_name);
+    free(key_name);
    if (ret != ERROR_SUCCESS)
    {
        TRACE("credentials for target name %s not found\n", debugstr_w(TargetName));
@ -1312,7 +1312,7 @@ BOOL WINAPI CredReadW(LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALW
    ret = registry_read_credential(hkeyCred, NULL, key_data, NULL, &len);
    if (ret == ERROR_SUCCESS)
    {
-        *Credential = heap_alloc(len);
+        *Credential = malloc(len);
        if (*Credential)
        {
            len = sizeof(**Credential);
@ -1375,7 +1375,7 @@ BOOL WINAPI CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInf
    if (TargetInformation->PackageName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->PackageName, -1, NULL, 0) * sizeof(WCHAR);

-    TargetInformationW = heap_alloc(len);
+    TargetInformationW = malloc(len);
    if (!TargetInformationW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
@ -1446,7 +1446,7 @@ BOOL WINAPI CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInf

    ret = CredReadDomainCredentialsW(TargetInformationW, Flags, Size, &CredentialsW);

-    heap_free(TargetInformationW);
+    free(TargetInformationW);

    if (ret)
    {
@ -1457,7 +1457,7 @@ BOOL WINAPI CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInf
        for (i = 0; i < *Size; i++)
            len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);

-        *Credentials = heap_alloc(len);
+        *Credentials = malloc(len);
        if (!*Credentials)
        {
            CredFree(CredentialsW);
@ -1519,7 +1519,7 @@ BOOL WINAPI CredWriteA(PCREDENTIALA Credential, DWORD Flags)
    }

    len = convert_PCREDENTIALA_to_PCREDENTIALW(Credential, NULL, 0);
-    CredentialW = heap_alloc(len);
+    CredentialW = malloc(len);
    if (!CredentialW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
@ -1530,7 +1530,7 @@ BOOL WINAPI CredWriteA(PCREDENTIALA Credential, DWORD Flags)

    ret = CredWriteW(CredentialW, Flags);

-    heap_free(CredentialW);
+    free(CredentialW);

    return ret;
 }
@ -1621,7 +1621,7 @@ BOOL WINAPI CredWriteW(PCREDENTIALW Credential, DWORD Flags)
    ret = RegCreateKeyExW(hkeyMgr, key_name, 0, NULL,
                          Credential->Persist == CRED_PERSIST_SESSION ? REG_OPTION_VOLATILE : REG_OPTION_NON_VOLATILE,
                          KEY_READ|KEY_WRITE, NULL, &hkeyCred, NULL);
-    heap_free(key_name);
+    free(key_name);
    if (ret != ERROR_SUCCESS)
    {
        TRACE("credentials for target name %s not found\n",
@ -1677,13 +1677,13 @@ BOOL WINAPI CredMarshalCredentialA( CRED_MARSHAL_TYPE type, PVOID cred, LPSTR *o
    if ((ret = CredMarshalCredentialW( type, cred, &outW )))
    {
        int len = WideCharToMultiByte( CP_ACP, 0, outW, -1, NULL, 0, NULL, NULL );
-        if (!(*out = heap_alloc( len )))
+        if (!(*out = malloc( len )))
        {
-            heap_free( outW );
+            free( outW );
            return FALSE;
        }
        WideCharToMultiByte( CP_ACP, 0, outW, -1, *out, len, NULL, NULL );
-        heap_free( outW );
+        free( outW );
    }
    return ret;
 }
@ -1741,7 +1741,7 @@ BOOL WINAPI CredMarshalCredentialW( CRED_MARSHAL_TYPE type, PVOID cred, LPWSTR *
    case CertCredential:
    {
        size = (sizeof(cert->rgbHashOfCert) + 2) * 4 / 3;
-        if (!(p = heap_alloc( (size + 4) * sizeof(WCHAR) ))) return FALSE;
+        if (!(p = malloc( (size + 4) * sizeof(WCHAR) ))) return FALSE;
        p[0] = '@';
        p[1] = '@';
        p[2] = 'A' + type;
@ -1753,7 +1753,7 @@ BOOL WINAPI CredMarshalCredentialW( CRED_MARSHAL_TYPE type, PVOID cred, LPWSTR *
    {
        len = lstrlenW( target->UserName );
        size = (sizeof(DWORD) + len * sizeof(WCHAR) + 2) * 4 / 3;
-        if (!(p = heap_alloc( (size + 4) * sizeof(WCHAR) ))) return FALSE;
+        if (!(p = malloc( (size + 4) * sizeof(WCHAR) ))) return FALSE;
        p[0] = '@';
        p[1] = '@';
        p[2] = 'A' + type;
@ -1786,11 +1786,11 @@ BOOL WINAPI CredUnmarshalCredentialA( LPCSTR cred, PCRED_MARSHAL_TYPE type, PVOI
    if (cred)
    {
        int len = MultiByteToWideChar( CP_ACP, 0, cred, -1, NULL, 0 );
-        if (!(credW = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
+        if (!(credW = malloc( len * sizeof(WCHAR) ))) return FALSE;
        MultiByteToWideChar( CP_ACP, 0, cred, -1, credW, len );
    }
    ret = CredUnmarshalCredentialW( credW, type, out );
-    heap_free( credW );
+    free( credW );
    return ret;
 }

@ -1876,7 +1876,7 @@ BOOL WINAPI CredUnmarshalCredentialW( LPCWSTR cred, PCRED_MARSHAL_TYPE type, PVO
            SetLastError( ERROR_INVALID_PARAMETER );
            return FALSE;
        }
-        if (!(cert = heap_alloc( sizeof(*cert) ))) return FALSE;
+        if (!(cert = malloc( sizeof(*cert) ))) return FALSE;
        memcpy( cert->rgbHashOfCert, hash, sizeof(cert->rgbHashOfCert) );
        cert->cbSize = sizeof(*cert);
        *out = cert;
@ -1894,10 +1894,10 @@ BOOL WINAPI CredUnmarshalCredentialW( LPCWSTR cred, PCRED_MARSHAL_TYPE type, PVO
            return FALSE;
        }
        buflen = sizeof(*target) + size + sizeof(WCHAR);
-        if (!(target = heap_alloc( buflen ))) return FALSE;
+        if (!(target = malloc( buflen ))) return FALSE;
        if (!cred_decode( cred + 9, len - 6, (char *)(target + 1) ))
        {
-            heap_free( target );
+            free( target );
            return FALSE;
        }
        target->UserName = (WCHAR *)(target + 1);
@ -1973,11 +1973,11 @@ BOOL WINAPI CredIsMarshaledCredentialA(LPCSTR name)
    if (name)
    {
        len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
-        nameW = heap_alloc(len * sizeof(WCHAR));
+        nameW = malloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, len);
    }

    res = CredIsMarshaledCredentialW(nameW);
-    heap_free(nameW);
+    free(nameW);
    return res;
 }
--- a/dlls/advapi32/crypt.h
+++ b/dlls/advapi32/crypt.h
@ -87,9 +87,9 @@ typedef struct tagCRYPTHASH
 #define MAXPROVTYPES 999

 extern unsigned char *CRYPT_DEShash( unsigned char *dst, const unsigned char *key,
-                                     const unsigned char *src ) DECLSPEC_HIDDEN;
+                                     const unsigned char *src );
 extern unsigned char *CRYPT_DESunhash( unsigned char *dst, const unsigned char *key,
-                                       const unsigned char *src ) DECLSPEC_HIDDEN;
+                                       const unsigned char *src );

 struct ustring {
    DWORD Length;
--- a/dlls/advapi32/eventlog.c
+++ b/dlls/advapi32/eventlog.c
@ -27,6 +27,7 @@
 #include "winerror.h"
 #include "winternl.h"
 #include "wmistr.h"
+#define _WMI_SOURCE_
 #include "evntrace.h"
 #include "evntprov.h"

@ -58,7 +59,7 @@ BOOL WINAPI BackupEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )

    backupW = strdupAW(lpBackupFileName);
    ret = BackupEventLogW(hEventLog, backupW);
-    heap_free(backupW);
+    free(backupW);

    return ret;
 }
@ -115,7 +116,7 @@ BOOL WINAPI ClearEventLogA( HANDLE hEventLog, LPCSTR lpBackupFileName )

    backupW = strdupAW(lpBackupFileName);
    ret = ClearEventLogW(hEventLog, backupW);
-    heap_free(backupW);
+    free(backupW);

    return ret;
 }
@ -394,8 +395,8 @@ HANDLE WINAPI OpenBackupEventLogA( LPCSTR lpUNCServerName, LPCSTR lpFileName )
    uncnameW = strdupAW(lpUNCServerName);
    filenameW = strdupAW(lpFileName);
    handle = OpenBackupEventLogW(uncnameW, filenameW);
-    heap_free(uncnameW);
-    heap_free(filenameW);
+    free(uncnameW);
+    free(filenameW);

    return handle;
 }
@ -453,8 +454,8 @@ HANDLE WINAPI OpenEventLogA( LPCSTR uncname, LPCSTR source )
    uncnameW = strdupAW(uncname);
    sourceW = strdupAW(source);
    handle = OpenEventLogW(uncnameW, sourceW);
-    heap_free(uncnameW);
-    heap_free(sourceW);
+    free(uncnameW);
+    free(sourceW);

    return handle;
 }
@ -608,7 +609,7 @@ BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD d
    if (wNumStrings == 0) return TRUE;
    if (!lpStrings) return TRUE;

-    wideStrArray = heap_alloc(sizeof(LPWSTR) * wNumStrings);
+    wideStrArray = malloc(sizeof(WCHAR *) * wNumStrings);
    for (i = 0; i < wNumStrings; i++)
    {
        RtlCreateUnicodeStringFromAsciiz(&str, lpStrings[i]);
@ -617,8 +618,8 @@ BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD d
    ret = ReportEventW(hEventLog, wType, wCategory, dwEventID, lpUserSid,
                       wNumStrings, dwDataSize, (LPCWSTR *)wideStrArray, lpRawData);
    for (i = 0; i < wNumStrings; i++)
-        heap_free( wideStrArray[i] );
-    heap_free(wideStrArray);
+        free(wideStrArray[i]);
+    free(wideStrArray);
    return ret;
 }

@ -642,20 +643,34 @@ BOOL WINAPI ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dw

    for (i = 0; i < wNumStrings; i++)
    {
-        switch (wType)
+        const WCHAR *line = lpStrings[i];
+
+        while (*line)
        {
-        case EVENTLOG_SUCCESS:
-            TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
-            break;
-        case EVENTLOG_ERROR_TYPE:
-            ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
-            break;
-        case EVENTLOG_WARNING_TYPE:
-            WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
-            break;
-        default:
-            TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i]));
-            break;
+            const WCHAR *next = wcschr( line, '\n' );
+
+            if (next)
+                ++next;
+            else
+                next = line + wcslen( line );
+
+            switch (wType)
+            {
+            case EVENTLOG_SUCCESS:
+                TRACE_(eventlog)("%s\n", debugstr_wn(line, next - line));
+                break;
+            case EVENTLOG_ERROR_TYPE:
+                ERR_(eventlog)("%s\n", debugstr_wn(line, next - line));
+                break;
+            case EVENTLOG_WARNING_TYPE:
+                WARN_(eventlog)("%s\n", debugstr_wn(line, next - line));
+                break;
+            default:
+                TRACE_(eventlog)("%s\n", debugstr_wn(line, next - line));
+                break;
+            }
+
+            line = next;
        }
    }
    return TRUE;
--- a/dlls/advapi32/lsa.c
+++ b/dlls/advapi32/lsa.c
@ -62,6 +62,33 @@ static void dumpLsaAttributes(const LSA_OBJECT_ATTRIBUTES *oa)
    }
 }

+static const char *debugstr_InformationClass( POLICY_INFORMATION_CLASS class )
+{
+    static const char * const names[] =
+    {
+        NULL,
+        "PolicyAuditLogInformation",
+        "PolicyAuditEventsInformation",
+        "PolicyPrimaryDomainInformation",
+        "PolicyPdAccountInformation",
+        "PolicyAccountDomainInformation",
+        "PolicyLsaServerRoleInformation",
+        "PolicyReplicaSourceInformation",
+        "PolicyDefaultQuotaInformation",
+        "PolicyModificationInformation",
+        "PolicyAuditFullSetInformation",
+        "PolicyAuditFullQueryInformation",
+        "PolicyDnsDomainInformation",
+        "PolicyDnsDomainInformationInt",
+        "PolicyLocalAccountDomainInformation",
+        "PolicyMachineAccountInformation",
+        "PolicyMachineAccountInformation2",
+    };
+
+    if (class < ARRAY_SIZE(names) && names[class]) return names[class];
+    return wine_dbg_sprintf( "%u", class );
+}
+
 static void* ADVAPI_GetDomainName(unsigned sz, unsigned ofs)
 {
    HKEY key;
@ -76,7 +103,7 @@ static void* ADVAPI_GetDomainName(unsigned sz, unsigned ofs)
        ret = RegQueryValueExW(key, L"Workgroup", NULL, NULL, NULL, &size);
        if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
        {
-            ptr = heap_alloc_zero(sz + size);
+            ptr = calloc(1, sz + size);
            if (!ptr) return NULL;
            ustr = (UNICODE_STRING*)(ptr + ofs);
            ustr->MaximumLength = size;
@ -84,16 +111,16 @@ static void* ADVAPI_GetDomainName(unsigned sz, unsigned ofs)
            ret = RegQueryValueExW(key, L"Workgroup", NULL, NULL, (LPBYTE)ustr->Buffer, &size);
            if (ret != ERROR_SUCCESS)
            {
-                heap_free(ptr);
+                free(ptr);
                ptr = NULL;
-            }   
+            }
            else ustr->Length = size - sizeof(WCHAR);
        }
        RegCloseKey(key);
    }
    if (!ptr)
    {
-        ptr = heap_alloc_zero(sz + sizeof(L"DOMAIN"));
+        ptr = calloc(1, sz + sizeof(L"DOMAIN"));
        if (!ptr) return NULL;
        ustr = (UNICODE_STRING*)(ptr + ofs);
        ustr->MaximumLength = sizeof(L"DOMAIN");
@ -117,7 +144,7 @@ NTSTATUS WINAPI LsaGetUserName(PUNICODE_STRING *user_name, PUNICODE_STRING *doma
    if (GetUserNameW(NULL, &user_size) || GetLastError() != ERROR_INSUFFICIENT_BUFFER)
       return STATUS_UNSUCCESSFUL;

-    user = heap_alloc(sizeof(*user) + user_size * sizeof(WCHAR));
+    user = malloc(sizeof(*user) + user_size * sizeof(WCHAR));
    if (!user) return STATUS_NO_MEMORY;

    user->Buffer = (WCHAR *)(user + 1);
@ -125,7 +152,7 @@ NTSTATUS WINAPI LsaGetUserName(PUNICODE_STRING *user_name, PUNICODE_STRING *doma
    user->Length = user->MaximumLength - sizeof(WCHAR);
    if (!GetUserNameW(user->Buffer, &user_size))
    {
-        heap_free(user);
+        free(user);
        return STATUS_UNSUCCESSFUL;
    }

@ -138,14 +165,14 @@ NTSTATUS WINAPI LsaGetUserName(PUNICODE_STRING *user_name, PUNICODE_STRING *doma
        domain_size = ARRAY_SIZE(computer);
        if (!GetComputerNameW(computer, &domain_size))
        {
-            heap_free(user);
+            free(user);
            return STATUS_UNSUCCESSFUL;
        }

-        domain = heap_alloc(sizeof(*domain) + (domain_size + 1) * sizeof(WCHAR));
+        domain = malloc(sizeof(*domain) + (domain_size + 1) * sizeof(WCHAR));
        if (!domain)
        {
-            heap_free(user);
+            free(user);
            return STATUS_NO_MEMORY;
        }

@ -335,7 +362,7 @@ NTSTATUS WINAPI LsaFreeMemory(IN PVOID Buffer)
 {
    TRACE("(%p)\n", Buffer);

-    heap_free(Buffer);
+    free(Buffer);
    return STATUS_SUCCESS;
 }

@ -470,22 +497,22 @@ NTSTATUS WINAPI LsaLookupNames2( LSA_HANDLE policy, ULONG flags, ULONG count,
    TRACE("mapped %lu out of %lu\n", mapped, count);

    size = sizeof(LSA_TRANSLATED_SID2) * count + sid_size_total;
-    if (!(*sids = heap_alloc(size))) return STATUS_NO_MEMORY;
+    if (!(*sids = malloc(size))) return STATUS_NO_MEMORY;

    sid = (SID *)(*sids + count);

    /* use maximum domain count */
-    if (!(*domains = heap_alloc(sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*count +
-                                sid_size_total + domainname_size_total*sizeof(WCHAR))))
+    if (!(*domains = malloc(sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION) * count +
+                            sid_size_total + domainname_size_total * sizeof(WCHAR))))
    {
-        heap_free(*sids);
+        free(*sids);
        return STATUS_NO_MEMORY;
    }
    (*domains)->Entries = 0;
    (*domains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*domains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
    domain_data = (char*)(*domains)->Domains + sizeof(LSA_TRUST_INFORMATION)*count;

-    domain.Buffer = heap_alloc(domain_size_max*sizeof(WCHAR));
+    domain.Buffer = malloc(domain_size_max * sizeof(WCHAR));
    for (i = 0; i < count; i++)
    {
        domain.Length = domain_size_max*sizeof(WCHAR);
@ -514,7 +541,7 @@ NTSTATUS WINAPI LsaLookupNames2( LSA_HANDLE policy, ULONG flags, ULONG count,
            }
        }
    }
-    heap_free(domain.Buffer);
+    free(domain.Buffer);

    if (mapped == count) return STATUS_SUCCESS;
    if (mapped > 0 && mapped < count) return STATUS_SOME_NOT_MAPPED;
@ -557,13 +584,13 @@ NTSTATUS WINAPI LsaLookupSids(

    /* this length does not include actual string length yet */
    name_fullsize = sizeof(LSA_TRANSLATED_NAME) * Count;
-    if (!(*Names = heap_alloc(name_fullsize))) return STATUS_NO_MEMORY;
+    if (!(*Names = malloc(name_fullsize))) return STATUS_NO_MEMORY;
    /* maximum count of stored domain infos is Count, allocate it like that cause really needed
       count could only be computed after sid data is retrieved */
    domain_fullsize = sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*Count;
-    if (!(*ReferencedDomains = heap_alloc(domain_fullsize)))
+    if (!(*ReferencedDomains = malloc(domain_fullsize)))
    {
-        heap_free(*Names);
+        free(*Names);
        return STATUS_NO_MEMORY;
    }
    (*ReferencedDomains)->Entries = 0;
@ -606,7 +633,7 @@ NTSTATUS WINAPI LsaLookupSids(
                domain_fullsize += domain_size * sizeof(WCHAR);

                /* get domain SID size too */
-                name = heap_alloc(domain_size * sizeof(WCHAR));
+                name = malloc(domain_size * sizeof(WCHAR));
                *name = 0;
                LookupAccountSidW(NULL, Sids[i], NULL, &name_size, name, &domain_size, &use);

@ -617,7 +644,7 @@ NTSTATUS WINAPI LsaLookupSids(
                lookup_name(&domain, NULL, &sid_size, NULL, &domain_size, &use, &handled);
                domain_fullsize += sid_size;

-                heap_free(name);
+                free(name);
            }
            else
            {
@ -638,10 +665,10 @@ NTSTATUS WINAPI LsaLookupSids(
    }

    /* now we have full length needed for both */
-    *Names = heap_realloc(*Names, name_fullsize);
+    *Names = realloc(*Names, name_fullsize);
    name_buffer = (WCHAR*)((char*)*Names + sizeof(LSA_TRANSLATED_NAME)*Count);

-    *ReferencedDomains = heap_realloc(*ReferencedDomains, domain_fullsize);
+    *ReferencedDomains = realloc(*ReferencedDomains, domain_fullsize);
    /* fix pointer after reallocation */
    (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
    domain_data = (char*)(*ReferencedDomains)->Domains + sizeof(LSA_TRUST_INFORMATION)*Count;
@ -670,13 +697,13 @@ NTSTATUS WINAPI LsaLookupSids(
                domain.MaximumLength = sizeof(WCHAR);
            }

-            domain.Buffer = heap_alloc(domain.MaximumLength);
+            domain.Buffer = malloc(domain.MaximumLength);

            LookupAccountSidW(NULL, Sids[i], (*Names)[i].Name.Buffer, &name_size, domain.Buffer, &domain_size, &use);
            (*Names)[i].Use = use;

            (*Names)[i].DomainIndex = lsa_reflist_add_domain(*ReferencedDomains, &domain, &domain_data);
-            heap_free(domain.Buffer);
+            free(domain.Buffer);
        }
        else if (ConvertSidToStringSidW(Sids[i], &strsid))
        {
@ -779,14 +806,14 @@ NTSTATUS WINAPI LsaQueryInformationPolicy(
    IN POLICY_INFORMATION_CLASS InformationClass,
    OUT PVOID *Buffer)
 {
-    TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
+    TRACE("(%p,%s,%p)\n", PolicyHandle, debugstr_InformationClass(InformationClass), Buffer);

    if(!Buffer) return STATUS_INVALID_PARAMETER;
    switch (InformationClass)
    {
        case PolicyAuditEventsInformation: /* 2 */
        {
-            PPOLICY_AUDIT_EVENTS_INFO p = heap_alloc_zero(sizeof(POLICY_AUDIT_EVENTS_INFO));
+            PPOLICY_AUDIT_EVENTS_INFO p = calloc(1, sizeof(POLICY_AUDIT_EVENTS_INFO));
            p->AuditingMode = FALSE; /* no auditing */
            *Buffer = p;
        }
@ -816,7 +843,7 @@ NTSTATUS WINAPI LsaQueryInformationPolicy(
            };

            DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
-            struct di * xdi = heap_alloc_zero(sizeof(*xdi));
+            struct di * xdi = calloc(1, sizeof(*xdi));

            xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR);
            xdi->info.DomainName.Buffer = xdi->domain;
@ -829,7 +856,7 @@ NTSTATUS WINAPI LsaQueryInformationPolicy(

            if (!ADVAPI_GetComputerSid(&xdi->sid))
            {
-                heap_free(xdi);
+                free(xdi);

                WARN("Computer SID not found\n");

@ -862,7 +889,7 @@ NTSTATUS WINAPI LsaQueryInformationPolicy(
            } computer_sid;
            DWORD dwSize;

-            xdi = heap_alloc_zero(sizeof(*xdi));
+            xdi = calloc(1, sizeof(*xdi));
            if (!xdi) return STATUS_NO_MEMORY;

            dwSize = 256;
@ -1016,7 +1043,7 @@ NTSTATUS WINAPI LsaSetInformationPolicy(
    IN POLICY_INFORMATION_CLASS InformationClass,
    IN PVOID Buffer)
 {
-    FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
+    FIXME("(%p,%s,%p) stub\n", PolicyHandle, debugstr_InformationClass(InformationClass), Buffer);

    return STATUS_UNSUCCESSFUL;
 }
@ -1129,7 +1156,7 @@ NTSTATUS WINAPI LsaLookupPrivilegeName(LSA_HANDLE handle, LUID *luid, LSA_UNICOD
        return STATUS_NO_SUCH_PRIVILEGE;

    length = lstrlenW(privnameW);
-    *name = heap_alloc(sizeof(**name) + (length + 1) * sizeof(WCHAR));
+    *name = malloc(sizeof(**name) + (length + 1) * sizeof(WCHAR));
    if (!*name)
        return STATUS_NO_MEMORY;

--- a/dlls/advapi32/registry.c
+++ b/dlls/advapi32/registry.c
@ -70,6 +70,9 @@ LSTATUS WINAPI RegOverridePredefKey( HKEY hkey, HKEY override )
 */
 LSTATUS WINAPI RegCreateKeyW( HKEY hkey, LPCWSTR lpSubKey, PHKEY phkResult )
 {
+    if (!phkResult)
+        return ERROR_INVALID_PARAMETER;
+
    return RegCreateKeyExW( hkey, lpSubKey, 0, NULL, REG_OPTION_NON_VOLATILE,
                            MAXIMUM_ALLOWED, NULL, phkResult, NULL );
 }
@ -82,6 +85,9 @@ LSTATUS WINAPI RegCreateKeyW( HKEY hkey, LPCWSTR lpSubKey, PHKEY phkResult )
 */
 LSTATUS WINAPI RegCreateKeyA( HKEY hkey, LPCSTR lpSubKey, PHKEY phkResult )
 {
+    if (!phkResult)
+        return ERROR_INVALID_PARAMETER;
+
    return RegCreateKeyExA( hkey, lpSubKey, 0, NULL, REG_OPTION_NON_VOLATILE,
                            MAXIMUM_ALLOWED, NULL, phkResult, NULL );
 }
--- a/dlls/advapi32/security.c
+++ b/dlls/advapi32/security.c
@ -185,7 +185,7 @@ static inline DWORD get_security_file( LPCWSTR full_file_name, DWORD access, HAN
 }

 /* helper function for SE_SERVICE objects in [Get|Set]NamedSecurityInfo */
-static inline DWORD get_security_service( LPWSTR full_service_name, DWORD access, HANDLE *service )
+static DWORD get_security_service( const WCHAR *full_service_name, DWORD access, HANDLE *service )
 {
    SC_HANDLE manager = OpenSCManagerW( NULL, NULL, access );
    if (manager)
@ -199,9 +199,9 @@ static inline DWORD get_security_service( LPWSTR full_service_name, DWORD access
 }

 /* helper function for SE_REGISTRY_KEY objects in [Get|Set]NamedSecurityInfo */
-static inline DWORD get_security_regkey( LPWSTR full_key_name, DWORD access, HANDLE *key )
+static DWORD get_security_regkey( const WCHAR *full_key_name, DWORD access, HANDLE *key )
 {
-    LPWSTR p = wcschr(full_key_name, '\\');
+    const WCHAR *p = wcschr(full_key_name, '\\');
    int len = p-full_key_name;
    HKEY hParent;

@ -234,12 +234,12 @@ BOOL ADVAPI_IsLocalComputer(LPCWSTR ServerName)
    if (!ServerName || !ServerName[0])
        return TRUE;

-    buf = heap_alloc(dwSize * sizeof(WCHAR));
+    buf = malloc(dwSize * sizeof(WCHAR));
    Result = GetComputerNameW(buf,  &dwSize);
    if (Result && (ServerName[0] == '\\') && (ServerName[1] == '\\'))
        ServerName += 2;
    Result = Result && !wcscmp(ServerName, buf);
-    heap_free(buf);
+    free(buf);

    return Result;
 }
@ -599,7 +599,7 @@ LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName,
    ret = LookupPrivilegeNameW(lpSystemNameW.Buffer, lpLuid, NULL, &wLen);
    if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
-        LPWSTR lpNameW = heap_alloc(wLen * sizeof(WCHAR));
+        LPWSTR lpNameW = malloc(wLen * sizeof(WCHAR));

        ret = LookupPrivilegeNameW(lpSystemNameW.Buffer, lpLuid, lpNameW,
         &wLen);
@ -628,7 +628,7 @@ LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName,
                *cchName = len - 1;
            }
        }
-        heap_free(lpNameW);
+        free(lpNameW);
    }
    RtlFreeUnicodeString(&lpSystemNameW);
    return ret;
@ -726,7 +726,7 @@ GetFileSecurityA( LPCSTR lpFileName,
    name = strdupAW(lpFileName);
    r = GetFileSecurityW( name, RequestedInformation, pSecurityDescriptor,
                          nLength, lpnLengthNeeded );
-    heap_free( name );
+    free( name );

    return r;
 }
@ -754,9 +754,9 @@ LookupAccountSidA(

    systemW = strdupAW(system);
    if (account)
-        accountW = heap_alloc( accountSizeW * sizeof(WCHAR) );
+        accountW = malloc( accountSizeW * sizeof(WCHAR) );
    if (domain)
-        domainW = heap_alloc( domainSizeW * sizeof(WCHAR) );
+        domainW = malloc( domainSizeW * sizeof(WCHAR) );

    r = LookupAccountSidW( systemW, sid, accountW, &accountSizeW, domainW, &domainSizeW, name_use );

@ -781,9 +781,9 @@ LookupAccountSidA(
        *domainSize = domainSizeW + 1;
    }

-    heap_free( systemW );
-    heap_free( accountW );
-    heap_free( domainW );
+    free( systemW );
+    free( accountW );
+    free( domainW );

    return r;
 }
@ -867,7 +867,7 @@ LookupAccountSidW(
            DWORD size = MAX_COMPUTERNAME_LENGTH + 1;
            BOOL result;

-            computer_name = heap_alloc(size * sizeof(WCHAR));
+            computer_name = malloc(size * sizeof(WCHAR));
            result = GetComputerNameW(computer_name,  &size);

            if (result) {
@ -921,7 +921,7 @@ LookupAccountSidW(
                            break;
                        case 1000:	/* first user account */
                            size = UNLEN + 1;
-                            account_name = heap_alloc(size * sizeof(WCHAR));
+                            account_name = malloc(size * sizeof(WCHAR));
                            if (GetUserNameW(account_name, &size))
                                ac = account_name;
                            else
@ -968,14 +968,14 @@ LookupAccountSidW(
        else
            *accountSize = ac_len + 1;

-        heap_free(account_name);
-        heap_free(computer_name);
+        free(account_name);
+        free(computer_name);
        if (status) *name_use = use;
        return status;
    }

-    heap_free(account_name);
-    heap_free(computer_name);
+    free(account_name);
+    free(computer_name);
    SetLastError(ERROR_NONE_MAPPED);
    return FALSE;
 }
@ -1009,7 +1009,7 @@ BOOL WINAPI SetFileSecurityA( LPCSTR lpFileName,

    name = strdupAW(lpFileName);
    r = SetFileSecurityW( name, RequestedInformation, pSecurityDescriptor );
-    heap_free( name );
+    free( name );

    return r;
 }
@ -1079,7 +1079,7 @@ LookupAccountNameA(
    RtlCreateUnicodeStringFromAsciiz(&lpAccountW, account);

    if (ReferencedDomainName)
-        lpReferencedDomainNameW = heap_alloc(*cbReferencedDomainName * sizeof(WCHAR));
+        lpReferencedDomainNameW = malloc(*cbReferencedDomainName * sizeof(WCHAR));

    ret = LookupAccountNameW(lpSystemW.Buffer, lpAccountW.Buffer, sid, cbSid, lpReferencedDomainNameW,
        cbReferencedDomainName, name_use);
@ -1092,7 +1092,7 @@ LookupAccountNameA(

    RtlFreeUnicodeString(&lpSystemW);
    RtlFreeUnicodeString(&lpAccountW);
-    heap_free(lpReferencedDomainNameW);
+    free(lpReferencedDomainNameW);

    return ret;
 }
@ -1279,7 +1279,7 @@ BOOL lookup_local_wellknown_name( const LSA_UNICODE_STRING *account_and_domain,
        {
            DWORD len, sidLen = SECURITY_MAX_SID_SIZE;

-            if (!(pSid = heap_alloc( sidLen ))) return FALSE;
+            if (!(pSid = malloc( sidLen ))) return FALSE;

            if ((ret = CreateWellKnownSid( ACCOUNT_SIDS[i].type, NULL, pSid, &sidLen )))
            {
@ -1311,7 +1311,7 @@ BOOL lookup_local_wellknown_name( const LSA_UNICODE_STRING *account_and_domain,
            if (ret)
                *peUse = ACCOUNT_SIDS[i].name_use;

-            heap_free(pSid);
+            free(pSid);
            *handled = TRUE;
            return ret;
        }
@ -1336,7 +1336,7 @@ BOOL lookup_local_user_name( const LSA_UNICODE_STRING *account_and_domain,
    /* Let the current Unix user id masquerade as first Windows user account */

    nameLen = UNLEN + 1;
-    if (!(userName = heap_alloc( nameLen * sizeof(WCHAR) ))) return FALSE;
+    if (!(userName = malloc( nameLen * sizeof(WCHAR) ))) return FALSE;

    if (domain.Buffer)
    {
@ -1367,7 +1367,7 @@ BOOL lookup_local_user_name( const LSA_UNICODE_STRING *account_and_domain,
        }
    }

-    heap_free(userName);
+    free(userName);
    return ret;
 }

@ -1497,6 +1497,10 @@ DWORD WINAPI GetSecurityInfo( HANDLE handle, SE_OBJECT_TYPE type, SECURITY_INFOR
    NTSTATUS status;
    ULONG size;
    BOOL present, defaulted;
+    HKEY key = NULL;
+
+    if (!handle)
+        return ERROR_INVALID_HANDLE;

    /* A NULL descriptor is allowed if any one of the other pointers is not NULL */
    if (!(ppsidOwner||ppsidGroup||ppDacl||ppSacl||ppSecurityDescriptor)) return ERROR_INVALID_PARAMETER;
@ -1509,8 +1513,9 @@ DWORD WINAPI GetSecurityInfo( HANDLE handle, SE_OBJECT_TYPE type, SECURITY_INFOR
    ||  ((SecurityInfo & SACL_SECURITY_INFORMATION)  && !ppSacl)  ))
        return ERROR_INVALID_PARAMETER;

-    if (type == SE_SERVICE)
+    switch (type)
    {
+    case SE_SERVICE:
        if (!QueryServiceObjectSecurity( handle, SecurityInfo, NULL, 0, &size )
            && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
            return GetLastError();
@ -1522,11 +1527,27 @@ DWORD WINAPI GetSecurityInfo( HANDLE handle, SE_OBJECT_TYPE type, SECURITY_INFOR
            LocalFree(sd);
            return GetLastError();
        }
-    }
-    else
-    {
-        HKEY key = NULL;
+        break;

+    case SE_WINDOW_OBJECT:
+        if (!GetUserObjectSecurity( handle, &SecurityInfo, NULL, 0, &size )
+                && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+            return GetLastError();
+
+        if (!(sd = LocalAlloc( 0, size )))
+            return ERROR_NOT_ENOUGH_MEMORY;
+
+        if (!GetUserObjectSecurity( handle, &SecurityInfo, sd, size, &size ))
+        {
+            LocalFree( sd );
+            return GetLastError();
+        }
+        break;
+
+    case SE_KERNEL_OBJECT:
+    case SE_FILE_OBJECT:
+    case SE_WMIGUID_OBJECT:
+    case SE_REGISTRY_KEY:
        if (type == SE_REGISTRY_KEY && (HandleToUlong(handle) >= HandleToUlong(HKEY_SPECIAL_ROOT_FIRST))
                && (HandleToUlong(handle) <= HandleToUlong(HKEY_SPECIAL_ROOT_LAST)))
        {
@ -1562,6 +1583,11 @@ DWORD WINAPI GetSecurityInfo( HANDLE handle, SE_OBJECT_TYPE type, SECURITY_INFOR
            return RtlNtStatusToDosError( status );
        }
        RegCloseKey( key );
+        break;
+
+    default:
+        FIXME("unimplemented type %u\n", type);
+        return ERROR_CALL_NOT_IMPLEMENTED;
    }

    if (ppsidOwner)
@ -1975,7 +2001,7 @@ static DWORD trustee_name_A_to_W(TRUSTEE_FORM form, char *trustee_nameA, WCHAR *

        if (objA)
        {
-            if (!(objW = heap_alloc( sizeof(OBJECTS_AND_NAME_W) )))
+            if (!(objW = malloc( sizeof(OBJECTS_AND_NAME_W) )))
                return ERROR_NOT_ENOUGH_MEMORY;

            objW->ObjectsPresent = objA->ObjectsPresent;
@ -2003,7 +2029,7 @@ static void free_trustee_name(TRUSTEE_FORM form, WCHAR *trustee_nameW)
    switch (form)
    {
    case TRUSTEE_IS_NAME:
-        heap_free( trustee_nameW );
+        free( trustee_nameW );
        break;
    case TRUSTEE_IS_OBJECTS_AND_NAME:
    {
@ -2011,10 +2037,10 @@ static void free_trustee_name(TRUSTEE_FORM form, WCHAR *trustee_nameW)

        if (objW)
        {
-            heap_free( objW->ptstrName );
-            heap_free( objW->InheritedObjectTypeName );
-            heap_free( objW->ObjectTypeName );
-            heap_free( objW );
+            free( objW->ptstrName );
+            free( objW->InheritedObjectTypeName );
+            free( objW->ObjectTypeName );
+            free( objW );
        }

        break;
@ -2093,7 +2119,7 @@ DWORD WINAPI SetEntriesInAclA( ULONG count, PEXPLICIT_ACCESSA pEntries,
    if (!count && !OldAcl)
        return ERROR_SUCCESS;

-    pEntriesW = heap_alloc( count * sizeof(EXPLICIT_ACCESSW) );
+    pEntriesW = malloc( count * sizeof(EXPLICIT_ACCESSW) );
    if (!pEntriesW)
        return ERROR_NOT_ENOUGH_MEMORY;

@ -2129,7 +2155,7 @@ cleanup:
    for (free_index = 0; free_index < alloc_index; ++free_index)
        free_trustee_name( pEntriesW[free_index].Trustee.TrusteeForm, pEntriesW[free_index].Trustee.ptstrName );

-    heap_free( pEntriesW );
+    free( pEntriesW );
    return err;
 }

@ -2154,7 +2180,7 @@ DWORD WINAPI SetEntriesInAclW( ULONG count, PEXPLICIT_ACCESSW pEntries,
        return ERROR_SUCCESS;

    /* allocate array of maximum sized sids allowed */
-    ppsid = heap_alloc(count * (sizeof(SID *) + FIELD_OFFSET(SID, SubAuthority[SID_MAX_SUB_AUTHORITIES])));
+    ppsid = malloc(count * (sizeof(SID *) + FIELD_OFFSET(SID, SubAuthority[SID_MAX_SUB_AUTHORITIES])));
    if (!ppsid)
        return ERROR_OUTOFMEMORY;

@ -2344,7 +2370,7 @@ DWORD WINAPI SetEntriesInAclW( ULONG count, PEXPLICIT_ACCESSW pEntries,
    }

 exit:
-    heap_free(ppsid);
+    free(ppsid);
    return ret;
 }

@ -2365,7 +2391,7 @@ DWORD WINAPI SetNamedSecurityInfoA(LPSTR pObjectName,
    r = SetNamedSecurityInfoW( wstr, ObjectType, SecurityInfo, psidOwner,
                           psidGroup, pDacl, pSacl );

-    heap_free( wstr );
+    free( wstr );

    return r;
 }
@ -2565,7 +2591,7 @@ BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorA(
    ret = ConvertStringSecurityDescriptorToSecurityDescriptorW(StringSecurityDescriptorW,
                                                               StringSDRevision, SecurityDescriptor,
                                                               SecurityDescriptorSize);
-    heap_free(StringSecurityDescriptorW);
+    free(StringSecurityDescriptorW);

    return ret;
 }
@ -2582,7 +2608,7 @@ BOOL WINAPI ConvertSecurityDescriptorToStringSecurityDescriptorA(PSECURITY_DESCR
        int lenA;

        lenA = WideCharToMultiByte(CP_ACP, 0, wstr, len, NULL, 0, NULL, NULL);
-        *OutputString = heap_alloc(lenA);
+        *OutputString = malloc(lenA);
        WideCharToMultiByte(CP_ACP, 0, wstr, len, *OutputString, lenA, NULL, NULL);
        LocalFree(wstr);

@ -2615,7 +2641,7 @@ BOOL WINAPI ConvertStringSidToSidA(LPCSTR StringSid, PSID* Sid)
    {
        WCHAR *wStringSid = strdupAW(StringSid);
        bret = ConvertStringSidToSidW(wStringSid, Sid);
-        heap_free(wStringSid);
+        free(wStringSid);
    }
    return bret;
 }
@ -2676,7 +2702,7 @@ BOOL WINAPI CreateProcessWithTokenW(HANDLE token, DWORD logon_flags, LPCWSTR app
 /******************************************************************************
 * GetNamedSecurityInfoA [ADVAPI32.@]
 */
-DWORD WINAPI GetNamedSecurityInfoA(LPSTR pObjectName,
+DWORD WINAPI GetNamedSecurityInfoA(const char *pObjectName,
        SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
        PSID* ppsidOwner, PSID* ppsidGroup, PACL* ppDacl, PACL* ppSacl,
        PSECURITY_DESCRIPTOR* ppSecurityDescriptor)
@ -2684,14 +2710,14 @@ DWORD WINAPI GetNamedSecurityInfoA(LPSTR pObjectName,
    LPWSTR wstr;
    DWORD r;

-    TRACE("%s %d %ld %p %p %p %p %p\n", pObjectName, ObjectType, SecurityInfo,
+    TRACE("%s %d %ld %p %p %p %p %p\n", debugstr_a(pObjectName), ObjectType, SecurityInfo,
        ppsidOwner, ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor);

    wstr = strdupAW(pObjectName);
    r = GetNamedSecurityInfoW( wstr, ObjectType, SecurityInfo, ppsidOwner,
                           ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor );

-    heap_free( wstr );
+    free( wstr );

    return r;
 }
@ -2699,7 +2725,7 @@ DWORD WINAPI GetNamedSecurityInfoA(LPSTR pObjectName,
 /******************************************************************************
 * GetNamedSecurityInfoW [ADVAPI32.@]
 */
-DWORD WINAPI GetNamedSecurityInfoW( LPWSTR name, SE_OBJECT_TYPE type,
+DWORD WINAPI GetNamedSecurityInfoW( const WCHAR *name, SE_OBJECT_TYPE type,
    SECURITY_INFORMATION info, PSID* owner, PSID* group, PACL* dacl,
    PACL* sacl, PSECURITY_DESCRIPTOR* descriptor )
 {
@ -2852,14 +2878,14 @@ static NTSTATUS combine_dacls(ACL *parent, ACL *child, ACL **result)
    int i;

    /* initialize a combined DACL containing both inherited and new ACEs */
-    combined = heap_alloc_zero(child->AclSize+parent->AclSize);
+    combined = calloc(1, child->AclSize + parent->AclSize);
    if (!combined)
        return STATUS_NO_MEMORY;

    status = RtlCreateAcl(combined, parent->AclSize+child->AclSize, ACL_REVISION);
    if (status != STATUS_SUCCESS)
    {
-        heap_free(combined);
+        free(combined);
        return status;
    }

@ -2914,6 +2940,9 @@ DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,
    PACL dacl = pDacl;
    NTSTATUS status;

+    if (!handle)
+        return ERROR_INVALID_HANDLE;
+
    if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION))
        return ERROR_INVALID_SECURITY_DESCR;

@ -2934,19 +2963,19 @@ DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,
            if (status != STATUS_BUFFER_TOO_SMALL)
                return RtlNtStatusToDosError(status);

-            psd = heap_alloc(size);
+            psd = malloc(size);
            if (!psd)
                return ERROR_NOT_ENOUGH_MEMORY;

            status = NtQuerySecurityObject(handle, SecurityInfo, psd, size, &size);
            if (status)
            {
-                heap_free(psd);
+                free(psd);
                return RtlNtStatusToDosError(status);
            }

            status = RtlGetControlSecurityDescriptor(psd, &control, &rev);
-            heap_free(psd);
+            free(psd);
            if (status)
                return RtlNtStatusToDosError(status);
            /* TODO: copy some control flags to new sd */
@ -2958,21 +2987,22 @@ DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,
                if (status != STATUS_INFO_LENGTH_MISMATCH)
                    return RtlNtStatusToDosError(status);

-                name_info = heap_alloc(size);
+                name_info = malloc(size);
                if (!name_info)
                    return ERROR_NOT_ENOUGH_MEMORY;

                status = NtQueryObject(handle, ObjectNameInformation, name_info, size, NULL);
                if (status)
                {
-                    heap_free(name_info);
+                    free(name_info);
                    return RtlNtStatusToDosError(status);
                }

-                for (name_info->Name.Length-=2; name_info->Name.Length>0; name_info->Name.Length-=2)
-                    if (name_info->Name.Buffer[name_info->Name.Length/2-1]=='\\' ||
-                            name_info->Name.Buffer[name_info->Name.Length/2-1]=='/')
-                        break;
+                if (name_info->Name.Length && name_info->Name.Buffer[(name_info->Name.Length / 2) - 1] == '\\')
+                    name_info->Name.Length -= 2;
+                while (name_info->Name.Length && name_info->Name.Buffer[(name_info->Name.Length / 2) - 1] != '\\')
+                    name_info->Name.Length -= 2;
+
                if (name_info->Name.Length)
                {
                    OBJECT_ATTRIBUTES attr;
@ -2992,7 +3022,7 @@ DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,
                    status = NtOpenFile(&parent, READ_CONTROL|SYNCHRONIZE, &attr, &io,
                            FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
                            FILE_OPEN_FOR_BACKUP_INTENT);
-                    heap_free(name_info);
+                    free(name_info);
                    if (!status)
                    {
                        err = GetSecurityInfo(parent, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION,
@ -3009,7 +3039,7 @@ DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,
                    }
                }
                else
-                    heap_free(name_info);
+                    free(name_info);
            }
        }

@ -3020,16 +3050,21 @@ DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,

    switch (ObjectType)
    {
-    case SE_SERVICE:
-        FIXME("stub: Service objects are not supported at this time.\n");
-        status = STATUS_SUCCESS; /* Implement SetServiceObjectSecurity */
-        break;
-    default:
+    case SE_FILE_OBJECT:
+    case SE_KERNEL_OBJECT:
+    case SE_WMIGUID_OBJECT:
+    case SE_REGISTRY_KEY:
        status = NtSetSecurityObject(handle, SecurityInfo, &sd);
        break;
+
+    default:
+        FIXME("unimplemented type %u, returning success\n", ObjectType);
+        status = STATUS_SUCCESS;
+        break;
+
    }
    if (dacl != pDacl)
-        heap_free(dacl);
+        free(dacl);
    return RtlNtStatusToDosError(status);
 }

@ -3066,6 +3101,19 @@ BOOL WINAPI SaferCloseLevel(SAFER_LEVEL_HANDLE handle)
    return TRUE;
 }

+/******************************************************************************
+ * TreeSetNamedSecurityInfoW   [ADVAPI32.@]
+ */
+DWORD WINAPI TreeSetNamedSecurityInfoW(WCHAR *name, SE_OBJECT_TYPE type, SECURITY_INFORMATION info,
+                                       SID *owner, SID *group, ACL *dacl, ACL *sacl, DWORD action,
+                                       FN_PROGRESS progress, PROG_INVOKE_SETTING pis, void *args)
+{
+    FIXME("(%s, %d, %lu, %p, %p, %p, %p, %lu, %p, %d, %p) stub\n",
+          debugstr_w(name), type, info, owner, group, dacl, sacl, action, progress, pis, args);
+
+    return ERROR_CALL_NOT_IMPLEMENTED;
+}
+
 /******************************************************************************
 * TreeResetNamedSecurityInfoW   [ADVAPI32.@]
 */
--- a/dlls/advapi32/service.c
+++ b/dlls/advapi32/service.c
@ -79,7 +79,7 @@ EnumServicesStatusA( SC_HANDLE hmngr, DWORD type, DWORD state, LPENUM_SERVICE_ST
    }

    sz = max( 2 * size, sizeof(*servicesW) );
-    if (!(servicesW = heap_alloc( sz )))
+    if (!(servicesW = malloc( sz )))
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return FALSE;
@ -113,7 +113,7 @@ EnumServicesStatusA( SC_HANDLE hmngr, DWORD type, DWORD state, LPENUM_SERVICE_ST
    ret = TRUE;

 done:
-    heap_free( servicesW );
+    free( servicesW );
    return ret;
 }

@ -150,7 +150,7 @@ EnumServicesStatusW( SC_HANDLE manager, DWORD type, DWORD state, ENUM_SERVICE_ST
            && GetLastError() != ERROR_MORE_DATA)
        return FALSE;

-    if (!(status_ex = heap_alloc( alloc_size )))
+    if (!(status_ex = malloc( alloc_size )))
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return FALSE;
@ -160,7 +160,7 @@ EnumServicesStatusW( SC_HANDLE manager, DWORD type, DWORD state, ENUM_SERVICE_ST
                                alloc_size, &alloc_size, &count, resume_handle, NULL )
            && GetLastError() != ERROR_MORE_DATA)
    {
-        heap_free( status_ex );
+        free( status_ex );
        return FALSE;
    }

@ -198,7 +198,7 @@ EnumServicesStatusW( SC_HANDLE manager, DWORD type, DWORD state, ENUM_SERVICE_ST
        status[i].ServiceStatus.dwWaitHint                = status_ex[i].ServiceStatusProcess.dwWaitHint;
    }

-    heap_free( status_ex );
+    free( status_ex );
    if (*ret_size > size)
    {
        SetLastError( ERROR_MORE_DATA );
@ -229,7 +229,7 @@ EnumServicesStatusExA( SC_HANDLE hmngr, SC_ENUM_TYPE level, DWORD type, DWORD st
          size, needed, returned, resume_handle, debugstr_a(group));

    sz = max( 2 * size, sizeof(*servicesW) );
-    if (!(servicesW = heap_alloc( sz )))
+    if (!(servicesW = malloc( sz )))
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return FALSE;
@ -237,10 +237,10 @@ EnumServicesStatusExA( SC_HANDLE hmngr, SC_ENUM_TYPE level, DWORD type, DWORD st
    if (group)
    {
        int len = MultiByteToWideChar( CP_ACP, 0, group, -1, NULL, 0 );
-        if (!(groupW = heap_alloc( len * sizeof(WCHAR) )))
+        if (!(groupW = malloc( len * sizeof(WCHAR) )))
        {
            SetLastError( ERROR_NOT_ENOUGH_MEMORY );
-            heap_free( servicesW );
+            free( servicesW );
            return FALSE;
        }
        MultiByteToWideChar( CP_ACP, 0, group, -1, groupW, len * sizeof(WCHAR) );
@ -275,8 +275,8 @@ EnumServicesStatusExA( SC_HANDLE hmngr, SC_ENUM_TYPE level, DWORD type, DWORD st
    ret = TRUE;

 done:
-    heap_free( servicesW );
-    heap_free( groupW );
+    free( servicesW );
+    free( groupW );
    return ret;
 }

@ -295,7 +295,7 @@ BOOL WINAPI GetServiceKeyNameA( SC_HANDLE hSCManager, LPCSTR lpDisplayName,

    lpDisplayNameW = strdupAW(lpDisplayName);
    if (lpServiceName)
-        lpServiceNameW = heap_alloc(*lpcchBuffer * sizeof(WCHAR));
+        lpServiceNameW = malloc(*lpcchBuffer * sizeof(WCHAR));
    else
        lpServiceNameW = NULL;

@ -321,8 +321,8 @@ BOOL WINAPI GetServiceKeyNameA( SC_HANDLE hSCManager, LPCSTR lpDisplayName,
    ret = TRUE;

 cleanup:
-    heap_free(lpServiceNameW);
-    heap_free(lpDisplayNameW);
+    free(lpServiceNameW);
+    free(lpDisplayNameW);
    return ret;
 }

@ -365,7 +365,7 @@ BOOL WINAPI GetServiceDisplayNameA( SC_HANDLE hSCManager, LPCSTR lpServiceName,

    lpServiceNameW = strdupAW(lpServiceName);
    if (lpDisplayName)
-        lpDisplayNameW = heap_alloc(*lpcchBuffer * sizeof(WCHAR));
+        lpDisplayNameW = malloc(*lpcchBuffer * sizeof(WCHAR));
    else
        lpDisplayNameW = NULL;

@ -392,8 +392,8 @@ BOOL WINAPI GetServiceDisplayNameA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
    ret = TRUE;

 cleanup:
-    heap_free(lpDisplayNameW);
-    heap_free(lpServiceNameW);
+    free(lpDisplayNameW);
+    free(lpServiceNameW);
    return ret;
 }

--- a/dlls/advapi32/tests/Makefile.in
+++ b/dlls/advapi32/tests/Makefile.in
@ -1,7 +1,7 @@
 TESTDLL   = advapi32.dll
-IMPORTS   = ole32 advapi32
+IMPORTS   = advapi32 user32

-C_SRCS = \
+SOURCES = \
 	cred.c \
 	crypt.c \
 	crypt_lmhash.c \
@ -12,7 +12,6 @@ C_SRCS = \
 	lsa.c \
 	perf.c \
 	registry.c \
+	rsrc.rc \
 	security.c \
 	service.c
-
-RC_SRCS = rsrc.rc
--- a/dlls/advapi32/tests/crypt.c
+++ b/dlls/advapi32/tests/crypt.c
@ -1260,10 +1260,10 @@ static void test_container_sd(void)
    ok(err == ERROR_INSUFFICIENT_BUFFER || broken(err == ERROR_INVALID_PARAMETER), "got %lu\n", err);
    ok(len, "expected len > 0\n");

-    sd = HeapAlloc(GetProcessHeap(), 0, len);
+    sd = malloc(len);
    ret = CryptGetProvParam(prov, PP_KEYSET_SEC_DESCR, (BYTE *)sd, &len, OWNER_SECURITY_INFORMATION);
    ok(ret, "got %lu\n", GetLastError());
-    HeapFree(GetProcessHeap(), 0, sd);
+    free(sd);

    ret = CryptReleaseContext(prov, 0);
    ok(ret, "got %lu\n", GetLastError());
--- a/dlls/advapi32/tests/eventlog.c
+++ b/dlls/advapi32/tests/eventlog.c
@ -30,6 +30,7 @@
 #include "wmistr.h"
 #include "evntprov.h"
 #include "evntrace.h"
+#include "netevent.h"

 #include "wine/test.h"

@ -103,24 +104,24 @@ static void test_open_close(void)

    SetLastError(0xdeadbeef);
    handle = OpenEventLogA(NULL, NULL);
-    ok(handle == NULL, "Didn't expect a handle\n");
+    ok(handle == NULL, "OpenEventLogA() succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());

    SetLastError(0xdeadbeef);
    handle = OpenEventLogA("IDontExist", NULL);
-    ok(handle == NULL, "Didn't expect a handle\n");
+    ok(handle == NULL, "OpenEventLogA(IDontExist,) succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());

    SetLastError(0xdeadbeef);
    handle = OpenEventLogA("IDontExist", "deadbeef");
-    ok(handle == NULL, "Didn't expect a handle\n");
+    ok(handle == NULL, "OpenEventLogA(IDontExist,deadbeef) succeeded\n");
    ok(GetLastError() == RPC_S_SERVER_UNAVAILABLE ||
       GetLastError() == RPC_S_INVALID_NET_ADDR, /* Some Vista and Win7 */
       "Expected RPC_S_SERVER_UNAVAILABLE, got %ld\n", GetLastError());

    /* This one opens the Application log */
    handle = OpenEventLogA(NULL, "deadbeef");
-    ok(handle != NULL, "Expected a handle : %ld\n", GetLastError());
+    ok(handle != NULL, "OpenEventLogA(deadbeef) failed : %ld\n", GetLastError());
    ret = CloseEventLog(handle);
    ok(ret, "Expected success : %ld\n", GetLastError());
    /* Close a second time */
@ -134,11 +135,11 @@ static void test_open_close(void)

    /* Empty servername should be read as local server */
    handle = OpenEventLogA("", "Application");
-    ok(handle != NULL, "Expected a handle : %ld\n", GetLastError());
+    ok(handle != NULL, "OpenEventLogA('',Application) failed : %ld\n", GetLastError());
    CloseEventLog(handle);

    handle = OpenEventLogA(NULL, "Application");
-    ok(handle != NULL, "Expected a handle : %ld\n", GetLastError());
+    ok(handle != NULL, "OpenEventLogA(Application) failed : %ld\n", GetLastError());
    CloseEventLog(handle);
 }

@ -444,14 +445,14 @@ static void test_read(void)
    todo_wine
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());

-    buf = HeapAlloc(GetProcessHeap(), 0, sizeof(EVENTLOGRECORD));
+    buf = malloc(sizeof(EVENTLOGRECORD));
    SetLastError(0xdeadbeef);
    ret = ReadEventLogA(NULL, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ,
                        0, buf, sizeof(EVENTLOGRECORD), &read, &needed);
    ok(!ret, "Expected failure\n");
    todo_wine
    ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %ld\n", GetLastError());
-    HeapFree(GetProcessHeap(), 0, buf);
+    free(buf);

    handle = OpenEventLogA(NULL, "Application");
    if (!handle && (GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == RPC_S_SERVER_UNAVAILABLE))
@ -462,7 +463,7 @@ static void test_read(void)
    ok(handle != NULL, "OpenEventLogA(Application) failed : %ld\n", GetLastError());

    /* Show that we need the proper dwFlags with a (for the rest) proper call */
-    buf = HeapAlloc(GetProcessHeap(), 0, sizeof(EVENTLOGRECORD));
+    buf = malloc(sizeof(EVENTLOGRECORD));

    SetLastError(0xdeadbeef);
    ret = ReadEventLogA(handle, 0, 0, buf, sizeof(EVENTLOGRECORD), &read, &needed);
@ -503,7 +504,7 @@ static void test_read(void)
    todo_wine
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());

-    HeapFree(GetProcessHeap(), 0, buf);
+    free(buf);

    /* First check if there are any records (in practice only on Wine: FIXME) */
    count = 0;
@ -516,7 +517,7 @@ static void test_read(void)
    }

    /* Get the buffer size for the first record */
-    buf = HeapAlloc(GetProcessHeap(), 0, sizeof(EVENTLOGRECORD));
+    buf = malloc(sizeof(EVENTLOGRECORD));
    read = needed = 0xdeadbeef;
    SetLastError(0xdeadbeef);
    ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ,
@ -528,7 +529,7 @@ static void test_read(void)

    /* Read the first record */
    toread = needed;
-    buf = HeapReAlloc(GetProcessHeap(), 0, buf, toread);
+    buf = realloc(buf, toread);
    read = needed = 0xdeadbeef;
    SetLastError(0xdeadbeef);
    ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 0, buf, toread, &read, &needed);
@ -537,7 +538,7 @@ static void test_read(void)
       broken(read < toread), /* NT4 wants a buffer size way bigger than just 1 record */
       "Expected the requested size to be read\n");
    ok(needed == 0, "Expected no extra bytes to be read\n");
-    HeapFree(GetProcessHeap(), 0, buf);
+    free(buf);

    CloseEventLog(handle);
 }
@ -779,11 +780,12 @@ static void test_readwrite(void)
    DWORD i;
    char *localcomputer = NULL;
    DWORD size;
+    void* buf;

    if (pCreateWellKnownSid)
    {
        sidsize = SECURITY_MAX_SID_SIZE;
-        user = HeapAlloc(GetProcessHeap(), 0, sidsize);
+        user = malloc(sidsize);
        SetLastError(0xdeadbeef);
        pCreateWellKnownSid(WinInteractiveSid, NULL, user, &sidsize);
        sidavailable = TRUE;
@ -816,6 +818,7 @@ static void test_readwrite(void)
        Sleep(2000);

        handle = OpenEventLogA(NULL, eventlogname);
+        ok(handle != NULL, "OpenEventLogA(%s) failed : %ld\n", eventlogname, GetLastError());
        count = 0xdeadbeef;
        GetNumberOfEventLogRecords(handle, &count);
        if (count != 0)
@ -843,12 +846,12 @@ static void test_readwrite(void)
        ok(ret, "Expected success : %ld\n", GetLastError());

        /* Needed to catch earlier Vista (with no ServicePack for example) */
-        buf = HeapAlloc(GetProcessHeap(), 0, sizeof(EVENTLOGRECORD));
+        buf = malloc(sizeof(EVENTLOGRECORD));
        if (!(ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ,
                                  0, buf, sizeof(EVENTLOGRECORD), &read, &needed)) &&
            GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        {
-            buf = HeapReAlloc(GetProcessHeap(), 0, buf, needed);
+            buf = realloc(buf, needed);
            ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ,
                                0, buf, needed, &read, &needed);
        }
@ -862,7 +865,7 @@ static void test_readwrite(void)
            if (record->EventType == EVENTLOG_SUCCESS)
                on_vista = TRUE;
        }
-        HeapFree(GetProcessHeap(), 0, buf);
+        free(buf);
    }

    /* This will clear the eventlog. The record numbering for new
@ -880,6 +883,8 @@ static void test_readwrite(void)
        DWORD oldest;
        BOOL run_sidtests = read_write[i].evt_sid & sidavailable;

+        winetest_push_context("%lu:%s", i, read_write[i].evt_src);
+
        /* We don't need to use RegisterEventSource to report events */
        if (i % 2)
            handle = OpenEventLogA(NULL, read_write[i].evt_src);
@ -916,9 +921,11 @@ static void test_readwrite(void)
        else
            ret = DeregisterEventSource(handle);
        ok(ret, "Expected success : %ld\n", GetLastError());
+        winetest_pop_context();
    }

    handle = OpenEventLogA(NULL, eventlogname);
+    ok(handle != NULL, "OpenEventLogA(%s) failed : %ld\n", eventlogname, GetLastError());
    count = 0xdeadbeef;
    ret = GetNumberOfEventLogRecords(handle, &count);
    ok(ret, "Expected success : %ld\n", GetLastError());
@ -942,23 +949,24 @@ static void test_readwrite(void)
        size = 0;
        SetLastError(0xdeadbeef);
        pGetComputerNameExA(ComputerNameDnsFullyQualified, NULL, &size);
-        localcomputer = HeapAlloc(GetProcessHeap(), 0, size);
+        localcomputer = malloc(size);
        pGetComputerNameExA(ComputerNameDnsFullyQualified, localcomputer, &size);
    }
    else
    {
        size = MAX_COMPUTERNAME_LENGTH + 1;
-        localcomputer = HeapAlloc(GetProcessHeap(), 0, size);
+        localcomputer = malloc(size);
        GetComputerNameA(localcomputer, &size);
    }

    /* Read all events from our created eventlog, one by one */
    handle = OpenEventLogA(NULL, eventlogname);
-    ok(handle != NULL, "Failed to open Event Log, got %ld\n", GetLastError());
+    ok(handle != NULL, "OpenEventLogA(%s) failed : %ld\n", eventlogname, GetLastError());
    i = 0;
+    size = sizeof(EVENTLOGRECORD) + 128;
+    buf = malloc(size);
    for (;;)
    {
-        void *buf;
        DWORD read, needed;
        EVENTLOGRECORD *record;
        char *sourcename, *computername;
@ -966,23 +974,33 @@ static void test_readwrite(void)
        char *ptr;
        BOOL run_sidtests = read_write[i].evt_sid & sidavailable;

-        buf = HeapAlloc(GetProcessHeap(), 0, sizeof(EVENTLOGRECORD));
+        winetest_push_context("%lu", i);
+
        SetLastError(0xdeadbeef);
        ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ,
                            0, buf, sizeof(EVENTLOGRECORD), &read, &needed);
        ok(!ret, "Expected failure\n");
        if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        {
-            HeapFree(GetProcessHeap(), 0, buf);
            ok(GetLastError() == ERROR_HANDLE_EOF, "record %ld, got %ld\n", i, GetLastError());
+            winetest_pop_context();
            break;
        }

-        buf = HeapReAlloc(GetProcessHeap(), 0, buf, needed);
+        if (needed > size)
+        {
+             free(buf);
+             size = needed;
+             buf = malloc(size);
+        }
        ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ,
                            0, buf, needed, &read, &needed);
        ok(ret, "Expected success: %ld\n", GetLastError());
-
+        if (!ret)
+        {
+             winetest_pop_context();
+             break;
+        }
        record = (EVENTLOGRECORD *)buf;

        ok(record->Length == read,
@ -1048,14 +1066,15 @@ static void test_readwrite(void)
        ok(record->Length == *(DWORD *)((BYTE *)buf + record->Length - sizeof(DWORD)),
           "Expected the closing DWORD to contain the length of the record\n");

-        HeapFree(GetProcessHeap(), 0, buf);
+        winetest_pop_context();
        i++;
    }
+    free(buf);
    CloseEventLog(handle);

    /* Test clearing a real eventlog */
    handle = OpenEventLogA(NULL, eventlogname);
-    ok(handle != NULL, "Failed to open Event Log, got %ld\n", GetLastError());
+    ok(handle != NULL, "OpenEventLogA(%s) failed : %ld\n", eventlogname, GetLastError());

    SetLastError(0xdeadbeef);
    ret = ClearEventLogA(handle, NULL);
@ -1069,8 +1088,8 @@ static void test_readwrite(void)
    CloseEventLog(handle);

 cleanup:
-    HeapFree(GetProcessHeap(), 0, localcomputer);
-    HeapFree(GetProcessHeap(), 0, user);
+    free(localcomputer);
+    free(user);
 }

 /* Before Vista:
@ -1137,24 +1156,10 @@ static void test_autocreation(void)
    /* On Windows we also automatically get an eventlog file */
    GetSystemDirectoryA(sysdir, sizeof(sysdir));

-    /* NT4 - W2K3 */
    lstrcpyA(eventlogfile, sysdir);
-    lstrcatA(eventlogfile, "\\config\\");
+    lstrcatA(eventlogfile, "\\winevt\\Logs\\");
    lstrcatA(eventlogfile, eventlogname);
-    lstrcatA(eventlogfile, ".evt");
-
-    if (GetFileAttributesA(eventlogfile) == INVALID_FILE_ATTRIBUTES)
-    {
-        /* Vista+ */
-        lstrcpyA(eventlogfile, sysdir);
-        lstrcatA(eventlogfile, "\\winevt\\Logs\\");
-        lstrcatA(eventlogfile, eventlogname);
-        lstrcatA(eventlogfile, ".evtx");
-    }
-
-    todo_wine
-    ok(GetFileAttributesA(eventlogfile) != INVALID_FILE_ATTRIBUTES,
-       "Expected an eventlog file\n");
+    lstrcatA(eventlogfile, ".evtx");

    if (pWow64RevertWow64FsRedirection)
        pWow64RevertWow64FsRedirection(redir);
@ -1235,7 +1240,7 @@ static void test_start_trace(void)
    LONG ret;

    buffersize = sizeof(EVENT_TRACE_PROPERTIES) + sizeof(sessionname) + sizeof(filepath);
-    properties = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buffersize);
+    properties = calloc(1, buffersize);
    properties->Wnode.BufferSize = buffersize;
    properties->Wnode.Flags = WNODE_FLAG_TRACED_GUID;
    properties->LogFileMode = EVENT_TRACE_FILE_MODE_NONE;
@ -1312,10 +1317,341 @@ static void test_start_trace(void)
    /* clean up */
    ControlTraceA(handle, sessionname, properties, EVENT_TRACE_CONTROL_STOP);
 done:
-    HeapFree(GetProcessHeap(), 0, properties);
+    free(properties);
    DeleteFileA(filepath);
 }

+static BOOL read_record(HANDLE handle, DWORD flags, DWORD offset, EVENTLOGRECORD **record, DWORD *size)
+{
+    DWORD read, needed;
+    BOOL ret;
+
+    SetLastError(0xdeadbeef);
+    memset(*record, 0, *size);
+    needed = 0;
+    if (!(ret = ReadEventLogW(handle, flags, offset, *record, *size, &read, &needed)) &&
+        GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+    {
+        free(*record);
+        *record = malloc(needed);
+        SetLastError(0xdeadbeef);
+        memset(*record, 0, needed);
+        *size = needed;
+        ret = ReadEventLogW(handle, flags, offset, *record, *size, &read, &needed);
+    }
+
+    return ret;
+}
+
+static void test_eventlog_start(void)
+{
+    BOOL ret, found;
+    HANDLE handle, handle2;
+    EVENTLOGRECORD *record, *record2;
+    DWORD size, size2, count, count2, read, needed;
+    WCHAR *sourcename, *computername, *localcomputer;
+    char *sourcenameA, *computernameA, *localcomputerA;
+
+    /* ReadEventLogW */
+    handle = OpenEventLogW(0, L"System");
+    if (!handle && (GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == RPC_S_SERVER_UNAVAILABLE))
+    {
+        win_skip( "Can't open System event log\n" );
+        return;
+    }
+    ok(handle != NULL, "OpenEventLogW(System) failed : %ld\n", GetLastError());
+    handle2 = OpenEventLogW(0, L"System");
+    todo_wine ok(handle != handle2, "Expected different handle\n");
+    CloseEventLog(handle2);
+
+    handle2 = OpenEventLogW(0, L"SYSTEM");
+    ok(!!handle2, "Expected valid handle\n");
+    CloseEventLog(handle2);
+
+    size = MAX_COMPUTERNAME_LENGTH + 1;
+    localcomputer = malloc(size * sizeof(WCHAR));
+    GetComputerNameW(localcomputer, &size);
+
+    ret = TRUE;
+    found = FALSE;
+    while (!found && ret)
+    {
+        read = needed = 0;
+        record = malloc(sizeof(EVENTLOGRECORD));
+        if (!(ret = ReadEventLogW(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,
+                                  0, record, sizeof(EVENTLOGRECORD), &read, &needed)) &&
+            GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+        {
+            record = realloc(record, needed);
+            ret = ReadEventLogW(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,
+                                0, record, needed, &read, &needed);
+            ok(needed == 0, "Expected 0, got %ld\n", needed);
+        }
+        if (ret && record->EventID == EVENT_EventlogStarted)
+        {
+            ok(record->Length == read, "Expected %ld, got %ld\n", read, record->Length);
+            ok(record->Reserved == 0x654c664c, "Expected 0x654c664c, got %ld\n", record->Reserved);
+            ok(record->RecordNumber > 0, "Expected 1 or higher, got %ld\n", record->RecordNumber);
+            ok(record->TimeGenerated == record->TimeWritten, "Expected time values to be the same\n");
+            ok(record->EventType == EVENTLOG_INFORMATION_TYPE,
+                "Expected %d, got %d\n", EVENTLOG_INFORMATION_TYPE, record->EventType);
+            ok(record->NumStrings == 0, "Expected 0, got %d\n", record->NumStrings);
+            ok(record->EventCategory == 0, "Expected 0, got %d\n", record->EventCategory);
+            ok(record->ReservedFlags == 0, "Expected 0, got %d\n", record->ReservedFlags);
+            ok(record->ClosingRecordNumber == 0, "Expected 0, got %ld\n", record->ClosingRecordNumber);
+            ok(record->StringOffset == record->UserSidOffset, "Expected offsets to be the same\n");
+            ok(record->UserSidLength == 0, "Expected 0, got %ld\n", record->UserSidLength);
+            ok(record->DataLength == 24, "Expected 24, got %ld\n", record->DataLength);
+            ok(record->DataOffset == record->UserSidOffset, "Expected offsets to be the same\n");
+
+            sourcename = (WCHAR *)(record + 1);
+            ok(!lstrcmpW(sourcename, L"EventLog"),
+                "Expected 'EventLog', got '%ls'\n", sourcename);
+
+            computername = sourcename + sizeof("EventLog");
+            ok(!lstrcmpiW(computername, localcomputer), "Expected '%ls', got '%ls'\n",
+                localcomputer, computername);
+
+            size = sizeof(EVENTLOGRECORD) + sizeof(L"EventLog") +
+                (lstrlenW(computername) + 1) * sizeof(WCHAR);
+            size = (size + 7) & ~7;
+            ok(record->DataOffset == size ||
+                broken(record->DataOffset == size - sizeof(WCHAR)), /* win8 */
+                "Expected %ld, got %ld\n", size, record->DataOffset);
+
+            found = TRUE;
+        }
+        free(record);
+    }
+    todo_wine ok(found, "EventlogStarted event not found\n");
+    CloseEventLog(handle);
+    free(localcomputer);
+
+    /* ReadEventLogA */
+    size = MAX_COMPUTERNAME_LENGTH + 1;
+    localcomputerA = malloc(size);
+    GetComputerNameA(localcomputerA, &size);
+
+    handle = OpenEventLogA(0, "System");
+    handle2 = OpenEventLogA(0, "SYSTEM");
+    todo_wine ok(handle != handle2, "Expected different handle\n");
+    CloseEventLog(handle2);
+
+    ret = TRUE;
+    found = FALSE;
+    while (!found && ret)
+    {
+        read = needed = 0;
+        record = malloc(sizeof(EVENTLOGRECORD));
+        if (!(ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,
+                                  0, record, sizeof(EVENTLOGRECORD), &read, &needed)) &&
+            GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+        {
+            record = realloc(record, needed);
+            ret = ReadEventLogA(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,
+                                0, record, needed, &read, &needed);
+            ok(needed == 0, "Expected 0, got %ld\n", needed);
+        }
+        if (ret && record->EventID == EVENT_EventlogStarted)
+        {
+            ok(record->Length == read, "Expected %ld, got %ld\n", read, record->Length);
+            ok(record->Reserved == 0x654c664c, "Expected 0x654c664c, got %ld\n", record->Reserved);
+            ok(record->RecordNumber > 0, "Expected 1 or higher, got %ld\n", record->RecordNumber);
+            ok(record->TimeGenerated == record->TimeWritten, "Expected time values to be the same\n");
+            ok(record->EventType == EVENTLOG_INFORMATION_TYPE,
+                "Expected %d, got %d\n", EVENTLOG_INFORMATION_TYPE, record->EventType);
+            ok(record->NumStrings == 0, "Expected 0, got %d\n", record->NumStrings);
+            ok(record->EventCategory == 0, "Expected 0, got %d\n", record->EventCategory);
+            ok(record->ReservedFlags == 0, "Expected 0, got %d\n", record->ReservedFlags);
+            ok(record->ClosingRecordNumber == 0, "Expected 0, got %ld\n", record->ClosingRecordNumber);
+            ok(record->StringOffset == record->UserSidOffset, "Expected offsets to be the same\n");
+            ok(record->UserSidLength == 0, "Expected 0, got %ld\n", record->UserSidLength);
+            ok(record->DataLength == 24, "Expected 24, got %ld\n", record->DataLength);
+            ok(record->DataOffset == record->UserSidOffset, "Expected offsets to be the same\n");
+
+            sourcenameA = (char *)(record + 1);
+            ok(!strcmp(sourcenameA, "EventLog"),
+                "Expected 'EventLog', got '%s'\n", sourcenameA);
+
+            computernameA = sourcenameA + sizeof("EventLog");
+            ok(!_stricmp(computernameA, localcomputerA), "Expected '%s', got '%s'\n",
+                localcomputerA, computernameA);
+
+            size = sizeof(EVENTLOGRECORD) + sizeof("EventLog") + strlen(computernameA) + 1;
+            size = (size + 7) & ~7;
+            ok(record->DataOffset == size ||
+                broken(record->DataOffset == size - 1), /* win8 */
+                "Expected %ld, got %ld\n", size, record->DataOffset);
+
+            found = TRUE;
+        }
+        free(record);
+    }
+    todo_wine ok(found, "EventlogStarted event not found\n");
+    CloseEventLog(handle);
+    free(localcomputerA);
+
+    /* SEQUENTIAL | FORWARDS - dwRecordOffset is ignored */
+    handle = OpenEventLogW(0, L"System");
+    size = sizeof(EVENTLOGRECORD) + 128;
+    record = malloc(size);
+    todo_wine {
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 100, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 1, "Expected 1, got %lu\n", record->RecordNumber);
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 200, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 2, "Expected 2, got %lu\n", record->RecordNumber);
+
+    /* change direction sequentially */
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 300, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 2, "Expected 2, got %lu\n", record->RecordNumber);
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 400, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 1, "Expected 1, got %lu\n", record->RecordNumber);
+    }
+
+    /* changing how is an error */
+    SetLastError(0xdeadbeef);
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_BACKWARDS_READ, 0, &record, &size);
+    ok(!ret, "Expected failure\n");
+    todo_wine
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
+    CloseEventLog(handle);
+
+    /* SEQUENTIAL | BACKWARDS - dwRecordOffset is ignored */
+    handle = OpenEventLogW(0, L"System");
+    count = 0xdeadbeef;
+    ret = GetNumberOfEventLogRecords(handle, &count);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    todo_wine
+    ok(count, "Zero records in log\n");
+
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 100, &record, &size);
+    todo_wine
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == count, "Expected %lu, got %lu\n", count, record->RecordNumber);
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 100, &record, &size);
+    todo_wine {
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == count - 1, "Expected %lu, got %lu\n", count - 1, record->RecordNumber);
+    }
+    CloseEventLog(handle);
+
+    handle = OpenEventLogW(0, L"System");
+    /* SEEK | FORWARDS */
+    /* bogus offset */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ, 0, &record, &size);
+    ok(!ret, "Expected failure\n");
+    todo_wine
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
+
+    count = 0xdeadbeef;
+    ret = GetNumberOfEventLogRecords(handle, &count);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ, count + 1, &record, &size);
+    ok(!ret, "Expected failure\n");
+    todo_wine
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
+
+    todo_wine {
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ, 2, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 2, "Expected 2, got %lu\n", record->RecordNumber);
+    /* skip one */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ, 4, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 4, "Expected 4, got %lu\n", record->RecordNumber);
+    /* seek an earlier one */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ, 3, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 3, "Expected 3, got %lu\n", record->RecordNumber);
+    /* change how */
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 100, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 4 || broken(record->RecordNumber == 5) /* some win10 22h2 */,
+        "Expected 4, got %lu\n", record->RecordNumber);
+    /* change direction */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_BACKWARDS_READ, 10, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 10, "Expected 10, got %lu\n", record->RecordNumber);
+    }
+    CloseEventLog(handle);
+
+    /* SEEK | BACKWARDS */
+    handle = OpenEventLogW(0, L"system");
+    /* bogus offset */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_BACKWARDS_READ, 0, &record, &size);
+    ok(!ret, "Expected failure\n");
+    todo_wine
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
+
+    todo_wine {
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_BACKWARDS_READ, 5, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 5, "Expected 5, got %lu\n", record->RecordNumber);
+    /* skip one */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_BACKWARDS_READ, 3, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 3, "Expected 3, got %lu\n", record->RecordNumber);
+    /* seek a later one */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_BACKWARDS_READ, 4, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 4, "Expected 4, got %lu\n", record->RecordNumber);
+    /* change how */
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 100, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 3 || broken(record->RecordNumber == 2) /* some win10 22h2 */,
+        "Expected 3, got %lu\n", record->RecordNumber);
+    /* change direction */
+    ret = read_record(handle, EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ, 10, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 10, "Expected 10, got %lu\n", record->RecordNumber);
+    }
+    CloseEventLog(handle);
+
+    /* reading same log with different handles */
+    handle = OpenEventLogW(0, L"System");
+    handle2 = OpenEventLogW(0, L"SYSTEM");
+    todo_wine {
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 0, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 1, "Expected 1, got %lu\n", record->RecordNumber);
+    ret = read_record(handle2, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 0, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(record->RecordNumber == 1, "Expected 1, got %lu\n", record->RecordNumber);
+    }
+    CloseEventLog(handle2);
+    CloseEventLog(handle);
+
+    /* using source name */
+    size2 = size;
+    record2 = malloc(size2);
+    handle = OpenEventLogW(0, L"System");
+    handle2 = OpenEventLogW(0, L"EventLog");
+    todo_wine {
+    ret = read_record(handle, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 0, &record, &size);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ret = read_record(handle2, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ, 0, &record2, &size2);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    }
+    ok(size == size2, "Expected %lu, got %lu\n", size, size2);
+    ok(!memcmp(record, record2, min(size, size2)), "Records miscompare\n");
+    count = 0xdeadbeef;
+    count2 = 0xdeadbeef;
+    ret = GetNumberOfEventLogRecords(handle, &count);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ret = GetNumberOfEventLogRecords(handle2, &count2);
+    ok(ret, "Expected success : %ld\n", GetLastError());
+    ok(count == count2, "Expected %lu, got %lu\n", count, count2);
+    CloseEventLog(handle2);
+    CloseEventLog(handle);
+
+    free(record2);
+    free(record);
+}
+
 START_TEST(eventlog)
 {
    SetLastError(0xdeadbeef);
@ -1349,4 +1685,6 @@ START_TEST(eventlog)

    /* Trace tests */
    test_start_trace();
+
+    test_eventlog_start();
 }
--- a/dlls/advapi32/tests/lsa.c
+++ b/dlls/advapi32/tests/lsa.c
@ -119,15 +119,8 @@ static void test_lsa(void)
                LPSTR name = NULL;
                LPSTR domain = NULL;
                LPSTR forest = NULL;
-                LPSTR guidstr = NULL;
-                WCHAR guidstrW[64];
                UINT len;
-                guidstrW[0] = '\0';
                ConvertSidToStringSidA(dns_domain_info->Sid, &strsid);
-                StringFromGUID2(&dns_domain_info->DomainGuid, guidstrW, ARRAY_SIZE(guidstrW));
-                len = WideCharToMultiByte( CP_ACP, 0, guidstrW, -1, NULL, 0, NULL, NULL );
-                guidstr = LocalAlloc( 0, len );
-                WideCharToMultiByte( CP_ACP, 0, guidstrW, -1, guidstr, len, NULL, NULL );
                if (dns_domain_info->Name.Buffer) {
                    len = WideCharToMultiByte( CP_ACP, 0, dns_domain_info->Name.Buffer, -1, NULL, 0, NULL, NULL );
                    name = LocalAlloc( 0, len );
@ -144,12 +137,11 @@ static void test_lsa(void)
                    WideCharToMultiByte( CP_ACP, 0, dns_domain_info->DnsForestName.Buffer, -1, forest, len, NULL, NULL );
                }
                trace("  name: %s domain: %s forest: %s guid: %s sid: %s\n",
-                      name ? name : "NULL", domain ? domain : "NULL",
-                      forest ? forest : "NULL", guidstr, strsid ? strsid : "NULL");
+                      debugstr_a(name), debugstr_a(domain), debugstr_a(forest),
+                      debugstr_guid(&dns_domain_info->DomainGuid), debugstr_a(strsid));
                LocalFree( name );
                LocalFree( forest );
                LocalFree( domain );
-                LocalFree( guidstr );
                LocalFree( strsid );
            }
            else
@ -251,15 +243,15 @@ static void test_LsaLookupNames2(void)
        return;
    }

-    name[0].Buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(n1));
+    name[0].Buffer = malloc(sizeof(n1));
    name[0].Length = name[0].MaximumLength = sizeof(n1);
    memcpy(name[0].Buffer, n1, sizeof(n1));

-    name[1].Buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(n1));
+    name[1].Buffer = malloc(sizeof(n1));
    name[1].Length = name[1].MaximumLength = sizeof(n1) - sizeof(WCHAR);
    memcpy(name[1].Buffer, n1, sizeof(n1) - sizeof(WCHAR));

-    name[2].Buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(n2));
+    name[2].Buffer = malloc(sizeof(n2));
    name[2].Length = name[2].MaximumLength = sizeof(n2);
    memcpy(name[2].Buffer, n2, sizeof(n2));

@ -315,9 +307,9 @@ static void test_LsaLookupNames2(void)
    LsaFreeMemory(sids);
    LsaFreeMemory(domains);

-    HeapFree(GetProcessHeap(), 0, name[0].Buffer);
-    HeapFree(GetProcessHeap(), 0, name[1].Buffer);
-    HeapFree(GetProcessHeap(), 0, name[2].Buffer);
+    free(name[0].Buffer);
+    free(name[1].Buffer);
+    free(name[2].Buffer);

    status = LsaClose(handle);
    ok(status == STATUS_SUCCESS, "LsaClose() failed, returned 0x%08lx\n", status);
--- a/dlls/advapi32/tests/registry.c
+++ b/dlls/advapi32/tests/registry.c
--- a/dlls/advapi32/tests/security.c
+++ b/dlls/advapi32/tests/security.c
--- a/dlls/advapi32/tests/service.c
+++ b/dlls/advapi32/tests/service.c
@ -1000,14 +1000,14 @@ static void test_query_svc(void)
    }

    /* Pass a correct buffer and buffersize but a NULL handle */
-    statusproc = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE_STATUS_PROCESS));
+    statusproc = malloc(sizeof(SERVICE_STATUS_PROCESS));
    bufsize = needed;
    SetLastError(0xdeadbeef);
    ret = pQueryServiceStatusEx(NULL, SC_STATUS_PROCESS_INFO, (BYTE*)statusproc, bufsize, &needed);
    ok(!ret, "Expected failure\n");
    ok(GetLastError() == ERROR_INVALID_HANDLE,
       "Expected ERROR_INVALID_HANDLE, got %ld\n", GetLastError());
-    HeapFree(GetProcessHeap(), 0, statusproc);
+    free(statusproc);

    /* Correct handle and info level */
    SetLastError(0xdeadbeef);
@ -1023,21 +1023,21 @@ static void test_query_svc(void)
    }

    /* All parameters are OK but we don't have enough rights */
-    statusproc = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE_STATUS_PROCESS));
+    statusproc = malloc(sizeof(SERVICE_STATUS_PROCESS));
    bufsize = sizeof(SERVICE_STATUS_PROCESS);
    SetLastError(0xdeadbeef);
    ret = pQueryServiceStatusEx(svc_handle, SC_STATUS_PROCESS_INFO, (BYTE*)statusproc, bufsize, &needed);
    ok(!ret, "Expected failure\n");
    ok(GetLastError() == ERROR_ACCESS_DENIED,
       "Expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
-    HeapFree(GetProcessHeap(), 0, statusproc);
+    free(statusproc);

    /* Open the service with just enough rights. */
    CloseServiceHandle(svc_handle);
    svc_handle = OpenServiceA(scm_handle, spooler, SERVICE_QUERY_STATUS);

    /* Everything should be fine now. */
-    statusproc = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE_STATUS_PROCESS));
+    statusproc = malloc(sizeof(SERVICE_STATUS_PROCESS));
    bufsize = sizeof(SERVICE_STATUS_PROCESS);
    SetLastError(0xdeadbeef);
    ret = pQueryServiceStatusEx(svc_handle, SC_STATUS_PROCESS_INFO, (BYTE*)statusproc, bufsize, &needed);
@ -1056,23 +1056,22 @@ static void test_query_svc(void)
    ok(broken(GetLastError() == ERROR_INVALID_PARAMETER) /* NT4 */ ||
       GetLastError() == ERROR_INVALID_ADDRESS, "got %ld\n", GetLastError());

-    HeapFree(GetProcessHeap(), 0, statusproc);
+    free(statusproc);

    CloseServiceHandle(svc_handle);
    CloseServiceHandle(scm_handle);
 }

-static void test_enum_svc(void)
+static BOOL test_enum_svc(int attempt)
 {
    SC_HANDLE scm_handle;
-    BOOL ret;
+    BOOL ret, alldone = FALSE;
    DWORD bufsize, needed, returned, resume;
-    DWORD neededW, returnedW;
+    DWORD neededA, returnedA;
    DWORD tempneeded, tempreturned, missing;
    DWORD servicecountactive, servicecountinactive;
-    ENUM_SERVICE_STATUSA *services;
-    ENUM_SERVICE_STATUSW *servicesW;
-    ENUM_SERVICE_STATUS_PROCESSA *exservices;
+    ENUM_SERVICE_STATUSA *servicesA;
+    ENUM_SERVICE_STATUSW *services;
    UINT i;

    /* All NULL or wrong  */
@ -1233,7 +1232,7 @@ static void test_enum_svc(void)
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
+    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
    ok(!ret, "Expected failure\n");
    ok(needed == 0 || broken(needed != 0), /* nt4 */
       "Expected needed buffer size to be set to 0, got %ld\n", needed);
@ -1250,81 +1249,110 @@ static void test_enum_svc(void)
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
    ok(!ret, "Expected failure\n");
    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for this one service\n");
    ok(returned == 0, "Expected no service returned, got %ld\n", returned);
    ok(GetLastError() == ERROR_MORE_DATA,
       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());

-    /* Test to show we get the same needed buffer size for the W-call */
-    neededW = 0xdeadbeef;
-    returnedW = 0xdeadbeef;
+    /* Test to show we get the same needed buffer size for the A-call */
+    neededA = 0xdeadbeef;
+    returnedA = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &neededW, &returnedW, NULL);
+    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &neededA, &returnedA, NULL);
    ok(!ret, "Expected failure\n");
-    ok(neededW != 0xdeadbeef && neededW > 0, "Expected the needed buffer size for this one service\n");
-    ok(neededW == needed, "Expected needed buffersize to be the same for A- and W-calls\n");
-    ok(returnedW == 0, "Expected no service returned, got %ld\n", returnedW);
    ok(GetLastError() == ERROR_MORE_DATA,
       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());
+    ok(neededA != 0xdeadbeef && neededA > 0, "Expected the needed buffer size for this one service\n");
+    ok(returnedA == 0, "Expected no service returned, got %ld\n", returnedA);
+    if (neededA != needed && attempt)
+         goto retry; /* service start|stop race condition */
+    ok(neededA == needed, "Expected needed buffersize to be the same for A- and W-calls\n");

    /* Store the needed bytes */
    tempneeded = needed;

    /* Allocate the correct needed bytes */
-    services = HeapAlloc(GetProcessHeap(), 0, needed);
+    services = malloc(needed);
    bufsize = needed;
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
                              services, bufsize, &needed, &returned, NULL);
+    free(services);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
    ok(ret, "Expected success, got error %lu\n", GetLastError());
    ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
    ok(returned != 0xdeadbeef && returned > 0, "Expected some returned services\n");
-    HeapFree(GetProcessHeap(), 0, services);

    /* Store the number of returned services */
    tempreturned = returned;

-    servicesW = HeapAlloc(GetProcessHeap(), 0, neededW);
-    bufsize = neededW;
-    neededW = 0xdeadbeef;
-    returnedW = 0xdeadbeef;
+    servicesA = malloc(neededA);
+    bufsize = neededA;
+    neededA = 0xdeadbeef;
+    returnedA = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
-                              servicesW, bufsize, &neededW, &returnedW, NULL);
-    ok(ret, "Expected success, got error %lu\n", GetLastError());
-    ok(neededW == 0, "Expected needed buffer to be 0 as we are done\n");
-    ok(returnedW != 0xdeadbeef && returnedW > 0, "Expected some returned services\n");
-    HeapFree(GetProcessHeap(), 0, servicesW);
+    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+                              servicesA, bufsize, &neededA, &returnedA, NULL);
+    free(servicesA);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
+    if (!ret && GetLastError() == ERROR_NOT_ENOUGH_MEMORY && GetACP() == CP_UTF8)
+         win_skip("Skipping some tests due to EnumServicesStatusA()'s broken UTF-8 support\n");
+    else
+    {
+         ok(ret, "Expected success, got error %lu\n", GetLastError());
+         ok(neededA == 0, "Expected needed buffer to be 0 as we are done\n");
+         ok(returnedA != 0xdeadbeef && returnedA > 0, "Expected some returned services\n");
+    }

-    /* Allocate less than the needed bytes and don't specify a resume handle */
-    services = HeapAlloc(GetProcessHeap(), 0, tempneeded);
-    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
+    /* Allocate less than the needed bytes and don't specify a resume handle.
+     * More than one service will be missing because of the space needed for
+     * the strings.
+     */
+    services = malloc(tempneeded);
+    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSW);
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
                              services, bufsize, &needed, &returned, NULL);
+    if (ret && needed == 0 && attempt)
+    {
+        free(services);
+        goto retry; /* service stop race condition */
+    }
    ok(!ret, "Expected failure\n");
-    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for this one service\n");
+    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size\n");
+    todo_wine ok(needed < tempneeded, "Expected a smaller needed buffer size for the missing services\n");
+    /* Experiments show bufsize + needed < tempneeded which proves the needed
+     * buffer size is an approximation. So it's best not to probe more.
+     */
    ok(returned < tempreturned, "Expected fewer services to be returned\n");
    ok(GetLastError() == ERROR_MORE_DATA,
       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());

    /* Allocate less than the needed bytes, this time with a correct resume handle */
-    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
+    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSW);
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    resume = 0;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
                              services, bufsize, &needed, &returned, &resume);
+    if (ret && needed == 0 && attempt)
+    {
+        free(services);
+        goto retry; /* service stop race condition */
+    }
    ok(!ret, "Expected failure\n");
-    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for this one service\n");
-    ok(returned < tempreturned, "Expected fewer services to be returned\n");
+    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for the missing services, got %lx\n", needed);
+    todo_wine ok(needed < tempneeded, "Expected < %lu bytes needed for the remaining services, got %lu\n", tempneeded, needed);
+    ok(returned < tempreturned, "Expected < %lu remaining services, got %lu\n", tempreturned, returned);
    todo_wine ok(resume, "Expected a resume handle\n");
    ok(GetLastError() == ERROR_MORE_DATA,
       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());
@ -1335,13 +1363,17 @@ static void test_enum_svc(void)
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
                              services, bufsize, &needed, &returned, &resume);
+    free(services);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
    ok(ret, "Expected success, got error %lu\n", GetLastError());
-    ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
-    todo_wine ok(returned == missing, "Expected %lu services to be returned\n", missing);
+    ok(needed == 0, "Expected 0 needed bytes as we are done, got %lu\n", needed);
+    if (returned < missing && strcmp(winetest_platform, "wine") && attempt)
+         goto retry; /* service stop race condition */
+    todo_wine ok(returned == missing, "Expected %lu remaining services, got %lu\n", missing, returned);
    ok(resume == 0, "Expected the resume handle to be 0\n");
-    HeapFree(GetProcessHeap(), 0, services);

    /* See if things add up */

@ -1356,47 +1388,59 @@ static void test_enum_svc(void)
     */

    /* Get the number of active win32 services */
-    EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_ACTIVE, NULL, 0,
+    EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_ACTIVE, NULL, 0,
                        &needed, &returned, NULL);
-    services = HeapAlloc(GetProcessHeap(), 0, needed);
-    EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_ACTIVE, services,
-                        needed, &needed, &returned, NULL);
-    HeapFree(GetProcessHeap(), 0, services);
+    services = malloc(needed);
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_ACTIVE,
+                              services, needed, &needed, &returned, NULL);
+    free(services);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */

    servicecountactive = returned;

    /* Get the number of inactive win32 services */
-    EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_INACTIVE, NULL, 0,
+    EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_INACTIVE, NULL, 0,
                        &needed, &returned, NULL);
-    services = HeapAlloc(GetProcessHeap(), 0, needed);
-    EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_INACTIVE, services,
-                        needed, &needed, &returned, NULL);
-    HeapFree(GetProcessHeap(), 0, services);
+    services = malloc(needed);
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_INACTIVE,
+                              services, needed, &needed, &returned, NULL);
+    free(services);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */

    servicecountinactive = returned;

    /* Get the number of win32 services */
-    EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0,
+    EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0,
                        &needed, &returned, NULL);
-    services = HeapAlloc(GetProcessHeap(), 0, needed);
-    EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, services,
-                        needed, &needed, &returned, NULL);
-    HeapFree(GetProcessHeap(), 0, services);
+    services = malloc(needed);
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+                              services, needed, &needed, &returned, NULL);
+    free(services);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */

    /* Check if total is the same as active and inactive win32 services */
-    ok(returned == (servicecountactive + servicecountinactive),
-       "Something wrong in the calculation\n");
+    if (returned != servicecountactive + servicecountinactive && attempt)
+         goto retry; /* service start|stop race condition */
+    ok(returned == servicecountactive + servicecountinactive,
+       "Expected service count %ld == %ld + %ld\n",
+       returned, servicecountactive, servicecountinactive);

    /* Get all drivers and services
     *
     * Fetch the status of the last call as failing could make the following tests crash
     * on Wine (we don't return anything yet).
     */
-    EnumServicesStatusA(scm_handle, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL,
+    EnumServicesStatusW(scm_handle, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL,
                        NULL, 0, &needed, &returned, NULL);
-    services = HeapAlloc(GetProcessHeap(), 0, needed);
-    ret = EnumServicesStatusA(scm_handle, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL,
+    services = malloc(needed);
+    ret = EnumServicesStatusW(scm_handle, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL,
                              services, needed, &needed, &returned, NULL);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
+    ok(ret, "Expected success %lu\n", GetLastError());

    /* Loop through all those returned drivers and services */
    for (i = 0; ret && i < returned; i++)
@ -1412,24 +1456,63 @@ static void test_enum_svc(void)
         */
        if (status.dwServiceType & (SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS))
        {
-            if (status.dwCurrentState == SERVICE_STOPPED)
-                servicecountinactive--;
-            else
+            switch (status.dwCurrentState)
+            {
+            case SERVICE_START_PENDING:
+            case SERVICE_STOP_PENDING:
+            case SERVICE_PAUSE_PENDING:
+            case SERVICE_PAUSED:
+            case SERVICE_CONTINUE_PENDING:
+                trace("Got state %lx for service %s\n", status.dwCurrentState,
+                      wine_dbgstr_w(services[i].lpServiceName));
+                /* fall through */
+
+            case SERVICE_RUNNING:
                servicecountactive--;
+                break;
+
+            case SERVICE_STOPPED:
+                servicecountinactive--;
+                break;
+
+            default:
+                ok(0, "Got unknown state %lx for service %s\n",
+                   status.dwCurrentState, wine_dbgstr_w(services[i].lpServiceName));
+                break;
+            }
        }
    }
-    HeapFree(GetProcessHeap(), 0, services);
+    free(services);

+    if ((servicecountactive || servicecountinactive) && attempt)
+         goto retry; /* service start|stop race condition */
    ok(servicecountactive == 0, "Active services mismatch %lu\n", servicecountactive);
    ok(servicecountinactive == 0, "Inactive services mismatch %lu\n", servicecountinactive);

+    alldone = TRUE;
+
+retry:
    CloseServiceHandle(scm_handle);
+    return alldone;
+}
+
+static BOOL test_enum_svc_ex(int attempt)
+{
+    SC_HANDLE scm_handle;
+    BOOL ret, alldone = FALSE;
+    DWORD bufsize, needed, returned, resume;
+    DWORD neededA, returnedA;
+    DWORD tempneeded, tempreturned, missing;
+    DWORD servicecountactive, servicecountinactive;
+    ENUM_SERVICE_STATUSW *services;
+    ENUM_SERVICE_STATUS_PROCESSW *exservices;
+    UINT i;

    /* More or less the same for EnumServicesStatusExA */
    if (!pEnumServicesStatusExA)
    {
        win_skip( "EnumServicesStatusExA not available\n" );
-        return;
+        return TRUE;
    }

    /* All NULL or wrong */
@ -1565,8 +1648,8 @@ static void test_enum_svc(void)
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
-                                 NULL, 0, &needed, &returned, NULL, "deadbeef_group");
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+                                 NULL, 0, &needed, &returned, NULL, L"deadbeef_group");
    ok(!ret, "Expected failure\n");
    ok(returned == 0, "Expected number of service to be set to 0, got %ld\n", returned);
    ok(needed == 0, "Expected needed buffer size to be set to 0, got %ld\n", needed);
@ -1581,7 +1664,7 @@ static void test_enum_svc(void)
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
                                 NULL, 0, &needed, &returned, NULL, NULL);
    ok(!ret, "Expected failure\n");
    ok(returned == 0, "Expected no service returned, got %ld\n", returned);
@ -1589,116 +1672,176 @@ static void test_enum_svc(void)
    ok(GetLastError() == ERROR_MORE_DATA,
       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());

-    /* Test to show we get the same needed buffer size for the W-call */
-    neededW = 0xdeadbeef;
-    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
-                                 NULL, 0, &neededW, &returnedW, NULL, NULL);
+    /* Test to show we get the same needed buffer size for the A-call */
+    neededA = 0xdeadbeef;
+    returnedA = 0xdeadbeef;
+    SetLastError(0xdeadbeef);
+    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+                                 NULL, 0, &neededA, &returnedA, NULL, NULL);
    ok(!ret, "Expected failure\n");
-    ok(neededW == needed, "Expected needed buffersize to be the same for A- and W-calls\n");
+    ok(GetLastError() == ERROR_MORE_DATA,
+       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());
+    ok(neededA != 0xdeadbeef && neededA > 0, "Expected the needed buffer size for this one service\n");
+    ok(returnedA == 0, "Expected no service returned, got %ld\n", returnedA);
+    if (neededA != needed && attempt)
+         goto retry; /* service start|stop race condition */
+    ok(neededA == needed, "Expected needed buffersize to be the same for A- and W-calls\n");
+    ok(GetLastError() == ERROR_MORE_DATA,
+       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());

    /* Store the needed bytes */
    tempneeded = needed;

-    /* Allocate the correct needed bytes */
-    exservices = HeapAlloc(GetProcessHeap(), 0, needed);
-    bufsize = needed;
-    needed = 0xdeadbeef;
+    /* Show the Ex call returns the same service count as the regular enum */
+    EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+                        NULL, 0, &needed, &returned, NULL);
+    services = malloc(needed);
    returned = 0xdeadbeef;
-    SetLastError(0xdeadbeef);
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
-                                 (BYTE*)exservices, bufsize, &needed, &returned, NULL, NULL);
+    ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
+                              services, needed, &needed, &returned, NULL);
+    free(services);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
    ok(ret, "Expected success, got error %lu\n", GetLastError());
    ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
-    ok(returned == tempreturned, "Expected the same number of service from this function\n");
-    HeapFree(GetProcessHeap(), 0, exservices);
+    ok(returned != 0xdeadbeef && returned > 0, "Expected some returned services\n");

    /* Store the number of returned services */
    tempreturned = returned;

-    /* Allocate less than the needed bytes and don't specify a resume handle */
-    exservices = HeapAlloc(GetProcessHeap(), 0, tempneeded);
-    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
+    /* Allocate the correct needed bytes */
+    exservices = malloc(tempneeded);
+    bufsize = tempneeded;
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
                                 (BYTE*)exservices, bufsize, &needed, &returned, NULL, NULL);
+    free(exservices);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
+    ok(ret, "Expected success, got error %lu\n", GetLastError());
+    ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
+    ok(returned == tempreturned, "Expected the same number of service from this function\n");
+
+    /* Store the number of returned services */
+    tempreturned = returned;
+
+    /* Allocate less than the needed bytes and don't specify a resume handle.
+     * More than one service will be missing because of the space needed for
+     * the strings.
+     */
+    exservices = malloc(tempneeded);
+    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSW);
+    needed = 0xdeadbeef;
+    returned = 0xdeadbeef;
+    SetLastError(0xdeadbeef);
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+                                 (BYTE*)exservices, bufsize, &needed, &returned, NULL, NULL);
+    if (ret && needed == 0 && attempt)
+    {
+        free(exservices);
+        goto retry; /* service stop race condition */
+    }
    ok(!ret, "Expected failure\n");
-    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size\n");
+    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for the missing services\n");
+    todo_wine ok(needed < tempneeded, "Expected a smaller needed buffer size for the missing services\n");
+    /* Experiments show bufsize + needed < tempneeded which proves the needed
+     * buffer size is an approximation. So it's best not to probe more.
+     */
    ok(returned < tempreturned, "Expected fewer services to be returned\n");
    ok(GetLastError() == ERROR_MORE_DATA,
       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());

    /* Allocate less than the needed bytes, this time with a correct resume handle */
-    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
+    bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSW);
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    resume = 0;
    SetLastError(0xdeadbeef);
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
                                 (BYTE*)exservices, bufsize, &needed, &returned, &resume, NULL);
+    if (ret && needed == 0 && attempt)
+    {
+        free(exservices);
+        goto retry; /* service stop race condition */
+    }
    ok(!ret, "Expected failure\n");
-    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size\n");
+    ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for the missing services\n");
+    todo_wine ok(needed < tempneeded, "Expected a smaller needed buffer size for the missing services\n");
    ok(returned < tempreturned, "Expected fewer services to be returned\n");
    todo_wine ok(resume, "Expected a resume handle\n");
    ok(GetLastError() == ERROR_MORE_DATA,
       "Expected ERROR_MORE_DATA, got %ld\n", GetLastError());

-    /* Fetch that last service but pass a bigger buffer size */
+    /* Fetch the missing services but pass a bigger buffer size */
    missing = tempreturned - returned;
    bufsize = tempneeded;
    needed = 0xdeadbeef;
    returned = 0xdeadbeef;
    SetLastError(0xdeadbeef);
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
                                 (BYTE*)exservices, bufsize, &needed, &returned, &resume, NULL);
+    free(exservices);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
    ok(ret, "Expected success, got error %lu\n", GetLastError());
    ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
    ok(returned == missing, "Expected %lu services to be returned\n", missing);
    ok(resume == 0, "Expected the resume handle to be 0\n");
-    HeapFree(GetProcessHeap(), 0, exservices);

    /* See if things add up */

    /* Get the number of active win32 services */
-    pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_ACTIVE,
+    pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_ACTIVE,
                           NULL, 0, &needed, &returned, NULL, NULL);
-    exservices = HeapAlloc(GetProcessHeap(), 0, needed);
-    pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_ACTIVE,
-                           (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
-    HeapFree(GetProcessHeap(), 0, exservices);
+    exservices = malloc(needed);
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_ACTIVE,
+                                 (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
+    free(exservices);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */

    servicecountactive = returned;

    /* Get the number of inactive win32 services */
-    pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_INACTIVE,
+    pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_INACTIVE,
                           NULL, 0, &needed, &returned, NULL, NULL);
-    exservices = HeapAlloc(GetProcessHeap(), 0, needed);
-    pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_INACTIVE,
-                           (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
-    HeapFree(GetProcessHeap(), 0, exservices);
+    exservices = malloc(needed);
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_INACTIVE,
+                                 (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
+    free(exservices);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */

    servicecountinactive = returned;

    /* Get the number of win32 services */
-    pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+    pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
                           NULL, 0, &needed, &returned, NULL, NULL);
-    exservices = HeapAlloc(GetProcessHeap(), 0, needed);
-    pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
-                           (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
-    HeapFree(GetProcessHeap(), 0, exservices);
+    exservices = malloc(needed);
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
+                                 (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
+    free(exservices);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */

    /* Check if total is the same as active and inactive win32 services */
-    ok(returned == (servicecountactive + servicecountinactive),
-       "Something wrong in the calculation\n");
+    if (returned != servicecountactive + servicecountinactive && attempt)
+         goto retry; /* service start|stop race condition */
+    ok(returned == servicecountactive + servicecountinactive,
+       "Expected service count %ld == %ld + %ld\n",
+       returned, servicecountactive, servicecountinactive);

    /* Get all drivers and services */
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32 | SERVICE_DRIVER,
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32 | SERVICE_DRIVER,
                                 SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL, NULL);
    ok(!ret, "Expected failure\n");
-    exservices = HeapAlloc(GetProcessHeap(), 0, needed);
-    ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32 | SERVICE_DRIVER,
+    exservices = malloc(needed);
+    ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32 | SERVICE_DRIVER,
                                 SERVICE_STATE_ALL, (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
+    if (!ret && GetLastError() == ERROR_MORE_DATA && attempt)
+        goto retry; /* service start race condition */
    ok(ret, "Expected success %lu\n", GetLastError());

    /* Loop through all those returned drivers and services */
@ -1723,30 +1866,60 @@ static void test_enum_svc(void)

        if (status.dwServiceType & (SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS))
        {
-            if (status.dwCurrentState != SERVICE_STOPPED)
+            switch (status.dwCurrentState)
            {
+            case SERVICE_START_PENDING:
+            case SERVICE_STOP_PENDING:
+                trace("Got state %lx (pid=%04lx) for service %s\n",
+                      status.dwCurrentState, status.dwProcessId,
+                      wine_dbgstr_w(exservices[i].lpServiceName));
+                /* There may or may not be a process id */
+                servicecountactive--;
+                break;
+
+            case SERVICE_PAUSE_PENDING:
+            case SERVICE_PAUSED:
+            case SERVICE_CONTINUE_PENDING:
+                trace("Got state %lx (pid=%04lx) for service %s\n",
+                      status.dwCurrentState, status.dwProcessId,
+                      wine_dbgstr_w(exservices[i].lpServiceName));
+                /* fall through */
+
+            case SERVICE_RUNNING:
                /* We expect a process id for every running service */
                ok(status.dwProcessId > 0, "Expected a process id for this running service (%s)\n",
-                   exservices[i].lpServiceName);
-
+                   wine_dbgstr_w(exservices[i].lpServiceName));
                servicecountactive--;
-            }
-            else
-            {
+                break;
+
+            case SERVICE_STOPPED:
                /* We shouldn't have a process id for inactive services */
                ok(status.dwProcessId == 0, "Service %s state %lu shouldn't have an associated process id\n",
-                   exservices[i].lpServiceName, status.dwCurrentState);
+                   wine_dbgstr_w(exservices[i].lpServiceName), status.dwCurrentState);

                servicecountinactive--;
+                break;
+
+            default:
+                ok(0, "Got unknown state %lx (pid=%04lx) for service %s\n",
+                   status.dwCurrentState, status.dwProcessId,
+                   wine_dbgstr_w(exservices[i].lpServiceName));
+                break;
            }
        }
    }
-    HeapFree(GetProcessHeap(), 0, exservices);
+    free(exservices);

+    if ((servicecountactive || servicecountinactive) && attempt)
+         goto retry; /* service start|stop race condition */
    ok(servicecountactive == 0, "Active services mismatch %lu\n", servicecountactive);
    ok(servicecountinactive == 0, "Inactive services mismatch %lu\n", servicecountinactive);

+    alldone = TRUE;
+
+retry:
    CloseServiceHandle(scm_handle);
+    return alldone;
 }

 static void test_close(void)
@ -1981,7 +2154,7 @@ static void test_sequence(void)
    ok(!ret, "Expected failure\n");
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Expected ERROR_INSUFFICIENT_BUFFER, got %ld\n", GetLastError());

-    config = HeapAlloc(GetProcessHeap(), 0, needed);
+    config = malloc(needed);
    given = needed;
    SetLastError(0xdeadbeef);
    ret = QueryServiceConfigA(svc_handle, config, given, &needed);
@ -2009,7 +2182,7 @@ static void test_sequence(void)
    ok(ret, "ChangeServiceConfig failed (err=%ld)\n", GetLastError());

    QueryServiceConfigA(svc_handle, NULL, 0, &needed);
-    config = HeapReAlloc(GetProcessHeap(), 0, config, needed);
+    config = realloc(config, needed);
    ok(QueryServiceConfigA(svc_handle, config, needed, &needed), "QueryServiceConfig failed\n");
    ok(config->lpBinaryPathName && config->lpLoadOrderGroup && config->lpDependencies && config->lpServiceStartName &&
        config->lpDisplayName, "Expected all string struct members to be non-NULL\n");
@ -2028,7 +2201,7 @@ static void test_sequence(void)
    ok(ret, "Expected success, got error %lu\n", GetLastError());
    CloseServiceHandle(svc_handle);
    CloseServiceHandle(scm_handle);
-    HeapFree(GetProcessHeap(), 0, config);
+    free(config);
 }

 static void test_queryconfig2(void)
@ -2717,7 +2890,7 @@ static void test_EventLog(void)
    ok(!ret, "QueryServiceConfig should fail\n");
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %lu\n", GetLastError());

-    config = HeapAlloc(GetProcessHeap(), 0, size);
+    config = malloc(size);
    ret = QueryServiceConfigA(svc_handle, config, size, &size);
    ok(ret, "QueryServiceConfig error %lu\n", GetLastError());

@ -2739,7 +2912,7 @@ static void test_EventLog(void)
       !strcmp(config->lpDisplayName, "Event Log") /* XP */ ||
       !strcmp(config->lpDisplayName, "Windows Event Log") /* Vista+ */, "got %s\n", config->lpDisplayName);

-    HeapFree(GetProcessHeap(), 0, config);
+    free(config);

    memset(&status, 0, sizeof(status));
    size = sizeof(status);
@ -2748,19 +2921,24 @@ static void test_EventLog(void)
    ok(status.dwServiceType == SERVICE_WIN32_SHARE_PROCESS ||
       status.dwServiceType == (SERVICE_WIN32_SHARE_PROCESS | SERVICE_WIN32_OWN_PROCESS) /* Win10 */,
       "got %#lx\n", status.dwServiceType);
-    ok(status.dwCurrentState == SERVICE_RUNNING, "got %#lx\n", status.dwCurrentState);
-    todo_wine
-    ok(status.dwControlsAccepted == SERVICE_ACCEPT_SHUTDOWN /* XP */ ||
-       status.dwControlsAccepted == (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN) /* 2008 */ ||
-       status.dwControlsAccepted == (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_TIMECHANGE | SERVICE_ACCEPT_SHUTDOWN),
-       "got %#lx\n", status.dwControlsAccepted);
-    ok(status.dwWin32ExitCode == 0, "got %#lx\n", status.dwWin32ExitCode);
    ok(status.dwServiceSpecificExitCode == 0, "got %#lx\n", status.dwServiceSpecificExitCode);
    ok(status.dwCheckPoint == 0, "got %#lx\n", status.dwCheckPoint);
    ok(status.dwWaitHint == 0, "got %#lx\n", status.dwWaitHint);
-    ok(status.dwProcessId != 0, "got %#lx\n", status.dwProcessId);
    ok(status.dwServiceFlags == 0 || status.dwServiceFlags == SERVICE_RUNS_IN_SYSTEM_PROCESS /* XP */,
       "got %#lx\n", status.dwServiceFlags);
+    if (status.dwCurrentState == SERVICE_STOPPED &&
+        status.dwWin32ExitCode == ERROR_PROCESS_ABORTED)
+        win_skip("EventLog crashed!\n");
+    else
+    {
+        ok(status.dwCurrentState == SERVICE_RUNNING, "got %#lx\n", status.dwCurrentState);
+        ok(status.dwControlsAccepted == SERVICE_ACCEPT_SHUTDOWN /* XP */ ||
+           status.dwControlsAccepted == (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN) /* 2008 */ ||
+           status.dwControlsAccepted == (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_TIMECHANGE | SERVICE_ACCEPT_SHUTDOWN),
+           "got %#lx\n", status.dwControlsAccepted);
+        ok(status.dwWin32ExitCode == 0, "got %#lx\n", status.dwWin32ExitCode);
+        ok(status.dwProcessId != 0, "got %#lx\n", status.dwProcessId);
+    }

    CloseServiceHandle(svc_handle);
    CloseServiceHandle(scm_handle);
@ -2822,6 +3000,7 @@ START_TEST(service)
    SC_HANDLE scm_handle;
    int myARGC;
    char** myARGV;
+    int attempt;

    myARGC = winetest_get_mainargs(&myARGV);
    GetFullPathNameA(myARGV[0], sizeof(selfname), selfname, NULL);
@ -2852,7 +3031,15 @@ START_TEST(service)
    test_get_displayname();
    test_get_servicekeyname();
    test_query_svc();
-    test_enum_svc();
+
+    /* Services may start or stop between enumeration calls, leading to
+     * inconsistencies and failures. So we may need a couple attempts.
+     */
+    for (attempt = 2; attempt >= 0; attempt--)
+        if (test_enum_svc(attempt)) break;
+    for (attempt = 2; attempt >= 0; attempt--)
+        if (test_enum_svc_ex(attempt)) break;
+
    test_close();
    test_wow64();
    /* Test the creation, querying and deletion of a service */
--- a/dlls/advpack/Makefile.in
+++ b/dlls/advpack/Makefile.in
@ -2,7 +2,7 @@ MODULE    = advpack.dll
 IMPORTLIB = advpack
 IMPORTS   = ole32 setupapi version advapi32

-C_SRCS = \
+SOURCES = \
 	advpack.c \
 	files.c \
 	install.c \
--- a/dlls/advpack/advpack.c
+++ b/dlls/advpack/advpack.c
@ -127,7 +127,7 @@ void set_ldids(HINF hInf, LPCWSTR pszInstallSection, LPCWSTR pszWorkingDir)
        if (!(value = wcschr(line, '=')))
        {
            SetupGetStringFieldW(&context, 0, NULL, 0, &size);
-            key = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
+            key = malloc(size * sizeof(WCHAR));
            key_copy = key;
            SetupGetStringFieldW(&context, 0, key, size, &size);
            value = line;
@ -165,7 +165,7 @@ void set_ldids(HINF hInf, LPCWSTR pszInstallSection, LPCWSTR pszWorkingDir)
            ldid = wcstol(ptr, NULL, 10);
            SetupSetDirectoryIdW(hInf, ldid, dest);
        }
-        HeapFree(GetProcessHeap(), 0, key_copy);
+        free(key_copy);
    } while (SetupFindNextLine(&context, &context));
 }

@ -227,7 +227,7 @@ BOOL WINAPI IsNTAdmin(DWORD reserved, LPDWORD pReserved)
        }
    }

-    pTokenGroups = HeapAlloc(GetProcessHeap(), 0, dwSize);
+    pTokenGroups = malloc(dwSize);
    if (!pTokenGroups)
    {
        CloseHandle(hToken);
@ -236,7 +236,7 @@ BOOL WINAPI IsNTAdmin(DWORD reserved, LPDWORD pReserved)

    if (!GetTokenInformation(hToken, TokenGroups, pTokenGroups, dwSize, &dwSize))
    {
-        HeapFree(GetProcessHeap(), 0, pTokenGroups);
+        free(pTokenGroups);
        CloseHandle(hToken);
        return FALSE;
    }
@ -246,7 +246,7 @@ BOOL WINAPI IsNTAdmin(DWORD reserved, LPDWORD pReserved)
    if (!AllocateAndInitializeSid(&SidAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &pSid))
    {
-        HeapFree(GetProcessHeap(), 0, pTokenGroups);
+        free(pTokenGroups);
        return FALSE;
    }

@ -259,7 +259,7 @@ BOOL WINAPI IsNTAdmin(DWORD reserved, LPDWORD pReserved)
        }
    }

-    HeapFree(GetProcessHeap(), 0, pTokenGroups);
+    free(pTokenGroups);
    FreeSid(pSid);

    return bSidFound;
@ -469,16 +469,13 @@ HRESULT WINAPI RegisterOCX(HWND hWnd, HINSTANCE hInst, LPCSTR cmdline, INT show)
    UNICODE_STRING cmdlineW;
    HRESULT hr = E_FAIL;
    HMODULE hm = NULL;
-    DWORD size;

    TRACE("(%s)\n", debugstr_a(cmdline));

    RtlCreateUnicodeStringFromAsciiz(&cmdlineW, cmdline);

-    size = (lstrlenW(cmdlineW.Buffer) + 1) * sizeof(WCHAR);
-    cmdline_copy = HeapAlloc(GetProcessHeap(), 0, size);
+    cmdline_copy = wcsdup(cmdlineW.Buffer);
    cmdline_ptr = cmdline_copy;
-    lstrcpyW(cmdline_copy, cmdlineW.Buffer);

    ocx_filename = get_parameter(&cmdline_ptr, ',', TRUE);
    if (!ocx_filename || !*ocx_filename)
@ -495,7 +492,7 @@ HRESULT WINAPI RegisterOCX(HWND hWnd, HINSTANCE hInst, LPCSTR cmdline, INT show)

 done:
    FreeLibrary(hm);
-    HeapFree(GetProcessHeap(), 0, cmdline_copy);
+    free(cmdline_copy);
    RtlFreeUnicodeString(&cmdlineW);

    return hr;
@ -636,7 +633,7 @@ HRESULT WINAPI TranslateInfStringA(LPCSTR pszInfFilename, LPCSTR pszInstallSecti

    if (res == S_OK)
    {
-        bufferW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+        bufferW = malloc(len * sizeof(WCHAR));

        res = TranslateInfStringW(filenameW.Buffer, installW.Buffer,
                                  translateW.Buffer, keyW.Buffer, bufferW,
@ -654,8 +651,8 @@ HRESULT WINAPI TranslateInfStringA(LPCSTR pszInfFilename, LPCSTR pszInstallSecti
            else
                res = E_NOT_SUFFICIENT_BUFFER;
        }
-        
-        HeapFree(GetProcessHeap(), 0, bufferW);
+
+        free(bufferW);
    }

    RtlFreeUnicodeString(&filenameW);
@ -753,7 +750,7 @@ HRESULT WINAPI TranslateInfStringExA(HINF hInf, LPCSTR pszInfFilename,

    if (res == S_OK)
    {
-        bufferW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+        bufferW = malloc(len * sizeof(WCHAR));

        res = TranslateInfStringExW(hInf, filenameW.Buffer, sectionW.Buffer,
                                keyW.Buffer, bufferW, len, &len, NULL);
@ -771,8 +768,8 @@ HRESULT WINAPI TranslateInfStringExA(HINF hInf, LPCSTR pszInfFilename,
            else
                res = E_NOT_SUFFICIENT_BUFFER;
        }
-        
-        HeapFree(GetProcessHeap(), 0, bufferW);
+
+        free(bufferW);
    }

    RtlFreeUnicodeString(&filenameW);
--- a/dlls/advpack/advpack_private.h
+++ b/dlls/advpack/advpack_private.h
@ -21,21 +21,19 @@
 #ifndef __ADVPACK_PRIVATE_H
 #define __ADVPACK_PRIVATE_H

-#include "wine/heap.h"
+HRESULT do_ocx_reg(HMODULE hocx, BOOL do_reg, const WCHAR *flags, const WCHAR *param);
+LPWSTR get_parameter(LPWSTR *params, WCHAR separator, BOOL quoted);
+void set_ldids(HINF hInf, LPCWSTR pszInstallSection, LPCWSTR pszWorkingDir);

-HRESULT do_ocx_reg(HMODULE hocx, BOOL do_reg, const WCHAR *flags, const WCHAR *param) DECLSPEC_HIDDEN;
-LPWSTR get_parameter(LPWSTR *params, WCHAR separator, BOOL quoted) DECLSPEC_HIDDEN;
-void set_ldids(HINF hInf, LPCWSTR pszInstallSection, LPCWSTR pszWorkingDir) DECLSPEC_HIDDEN;
+HRESULT launch_exe(LPCWSTR cmd, LPCWSTR dir, HANDLE *phEXE);

-HRESULT launch_exe(LPCWSTR cmd, LPCWSTR dir, HANDLE *phEXE) DECLSPEC_HIDDEN;
-
-static inline char *heap_strdupWtoA(const WCHAR *str)
+static inline char *strdupWtoA(const WCHAR *str)
 {
    char *ret = NULL;

    if(str) {
        size_t size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
-        ret = heap_alloc(size);
+        ret = malloc(size);
        if(ret)
            WideCharToMultiByte(CP_ACP, 0, str, -1, ret, size, NULL, NULL);
    }
--- a/dlls/advpack/files.c
+++ b/dlls/advpack/files.c
@ -46,7 +46,7 @@ static LPWSTR ansi_to_unicode_list(LPCSTR ansi_list)
    while (*ptr) ptr += lstrlenA(ptr) + 1;
    len = ptr + 1 - ansi_list;
    wlen = MultiByteToWideChar(CP_ACP, 0, ansi_list, len, NULL, 0);
-    list = HeapAlloc(GetProcessHeap(), 0, wlen * sizeof(WCHAR));
+    list = malloc(wlen * sizeof(WCHAR));
    MultiByteToWideChar(CP_ACP, 0, ansi_list, len, list, wlen);
    return list;
 }
@ -82,7 +82,7 @@ HRESULT WINAPI AddDelBackupEntryA(LPCSTR lpcszFileList, LPCSTR lpcszBackupDir,

    res = AddDelBackupEntryW(filelist, backup, basename.Buffer, dwFlags);

-    HeapFree(GetProcessHeap(), 0, filelist);
+    free(filelist);

    RtlFreeUnicodeString(&backupdir);
    RtlFreeUnicodeString(&basename);
@ -246,7 +246,7 @@ HRESULT WINAPI AdvInstallFileW(HWND hwnd, LPCWSTR lpszSourceDir, LPCWSTR lpszSou
    LPWSTR szDestFilename;
    LPCWSTR szPath;
    WCHAR szRootPath[ROOT_LENGTH];
-    DWORD dwLen, dwLastError;
+    DWORD dwLastError;
    HSPFILEQ fileQueue;
    PVOID pContext;

@ -268,18 +268,7 @@ HRESULT WINAPI AdvInstallFileW(HWND hwnd, LPCWSTR lpszSourceDir, LPCWSTR lpszSou
    szPath = lpszSourceDir + ROOT_LENGTH;

    /* use lpszSourceFile as destination filename if lpszDestFile is NULL */
-    if (lpszDestFile)
-    {
-        dwLen = lstrlenW(lpszDestFile);
-        szDestFilename = HeapAlloc(GetProcessHeap(), 0, (dwLen+1) * sizeof(WCHAR));
-        lstrcpyW(szDestFilename, lpszDestFile);
-    }
-    else
-    {
-        dwLen = lstrlenW(lpszSourceFile);
-        szDestFilename = HeapAlloc(GetProcessHeap(), 0, (dwLen+1) * sizeof(WCHAR));
-        lstrcpyW(szDestFilename, lpszSourceFile);
-    }
+    szDestFilename = wcsdup(lpszDestFile ? lpszDestFile : lpszSourceFile);

    /* add the file copy operation to the setup queue */
    if (!SetupQueueCopyW(fileQueue, szRootPath, szPath, lpszSourceFile, NULL,
@ -313,9 +302,9 @@ HRESULT WINAPI AdvInstallFileW(HWND hwnd, LPCWSTR lpszSourceDir, LPCWSTR lpszSou
 done:
    SetupTermDefaultQueueCallback(pContext);
    SetupCloseFileQueue(fileQueue);
-    
-    HeapFree(GetProcessHeap(), 0, szDestFilename);
-    
+
+    free(szDestFilename);
+
    return HRESULT_FROM_WIN32(dwLastError);
 }

@ -483,9 +472,8 @@ HRESULT WINAPI DelNodeRunDLL32W(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT

    TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_w(cmdline), show);

-    cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
+    cmdline_copy = wcsdup(cmdline);
    cmdline_ptr = cmdline_copy;
-    lstrcpyW(cmdline_copy, cmdline);

    /* get the parameters at indexes 0 and 1 respectively */
    szFilename = get_parameter(&cmdline_ptr, ',', TRUE);
@ -496,7 +484,7 @@ HRESULT WINAPI DelNodeRunDLL32W(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT

    res = DelNodeW(szFilename, dwFlags);

-    HeapFree(GetProcessHeap(), 0, cmdline_copy);
+    free(cmdline_copy);

    return res;
 }
@ -549,14 +537,14 @@ static LPSTR convert_file_list(LPCSTR FileList, DWORD *dwNumFiles)
        return NULL;

    dwLen = last - first + 3; /* room for double-null termination */
-    szConvertedList = HeapAlloc(GetProcessHeap(), 0, dwLen);
+    szConvertedList = malloc(dwLen);
    lstrcpynA(szConvertedList, first, dwLen - 1);
    szConvertedList[dwLen - 1] = '\0';

    /* empty list */
    if (!szConvertedList[0])
    {
-        HeapFree(GetProcessHeap(), 0, szConvertedList);
+        free(szConvertedList);
        return NULL;
    }
        
@ -580,8 +568,8 @@ static LPSTR convert_file_list(LPCSTR FileList, DWORD *dwNumFiles)

 static void free_file_node(struct FILELIST *pNode)
 {
-    HeapFree(GetProcessHeap(), 0, pNode->FileName);
-    HeapFree(GetProcessHeap(), 0, pNode);
+    free(pNode->FileName);
+    free(pNode);
 }

 /* determines whether szFile is in the NULL-separated szFileList */
@ -731,7 +719,7 @@ HRESULT WINAPI ExtractFilesA(LPCSTR CabName, LPCSTR ExpandDir, DWORD Flags,
 done:
    free_file_list(&session);
    FreeLibrary(hCabinet);
-    HeapFree(GetProcessHeap(), 0, szConvertedList);
+    free(szConvertedList);

    return res;
 }
@ -774,19 +762,19 @@ HRESULT WINAPI ExtractFilesW(LPCWSTR CabName, LPCWSTR ExpandDir, DWORD Flags,
          Flags, debugstr_w(FileList), LReserved, Reserved);

    if(CabName) {
-        cab_name = heap_strdupWtoA(CabName);
+        cab_name = strdupWtoA(CabName);
        if(!cab_name)
            return E_OUTOFMEMORY;
    }

    if(ExpandDir) {
-        expand_dir = heap_strdupWtoA(ExpandDir);
+        expand_dir = strdupWtoA(ExpandDir);
        if(!expand_dir)
            hres = E_OUTOFMEMORY;
    }

    if(SUCCEEDED(hres) && FileList) {
-        file_list = heap_strdupWtoA(FileList);
+        file_list = strdupWtoA(FileList);
        if(!file_list)
            hres = E_OUTOFMEMORY;
    }
@ -796,9 +784,9 @@ HRESULT WINAPI ExtractFilesW(LPCWSTR CabName, LPCWSTR ExpandDir, DWORD Flags,
    if(SUCCEEDED(hres))
        hres = ExtractFilesA(cab_name, expand_dir, Flags, file_list, LReserved, Reserved);

-    heap_free(cab_name);
-    heap_free(expand_dir);
-    heap_free(file_list);
+    free(cab_name);
+    free(expand_dir);
+    free(file_list);
    return hres;
 }

@ -1078,7 +1066,7 @@ HRESULT WINAPI GetVersionFromFileExW(LPCWSTR lpszFilename, LPDWORD pdwMSVer,
            goto done;
    }

-    pVersionInfo = HeapAlloc(GetProcessHeap(), 0, dwInfoSize);
+    pVersionInfo = malloc(dwInfoSize);
    if (!pVersionInfo)
        goto done;

@ -1110,7 +1098,7 @@ HRESULT WINAPI GetVersionFromFileExW(LPCWSTR lpszFilename, LPDWORD pdwMSVer,
    }

 done:
-    HeapFree(GetProcessHeap(), 0, pVersionInfo);
+    free(pVersionInfo);

    if (bFileCopied)
        DeleteFileW(szFile);
--- a/dlls/advpack/install.c
+++ b/dlls/advpack/install.c
@ -227,13 +227,13 @@ static WCHAR *get_field_string(INFCONTEXT *context, DWORD index, WCHAR *buffer,
    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
        /* now grow the buffer */
-        if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
-        if (!(buffer = HeapAlloc(GetProcessHeap(), 0, required*sizeof(WCHAR)))) return NULL;
+        if (buffer != static_buffer) free(buffer);
+        if (!(buffer = malloc(required*sizeof(WCHAR)))) return NULL;
        *size = required;
        if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer;
    }

-    if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
+    if (buffer != static_buffer) free(buffer);
    return NULL;
 }

@ -267,7 +267,7 @@ static HRESULT iterate_section_fields(HINF hinf, PCWSTR section, PCWSTR key,
    hr = S_OK;

 done:
-    if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
+    if (buffer != static_buffer) free(buffer);
    return hr;
 }

@ -401,7 +401,7 @@ static HRESULT get_working_dir(ADVInfo *info, LPCWSTR inf_filename, LPCWSTR work
        ptr = path;
    }

-    info->working_dir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+    info->working_dir = malloc(len * sizeof(WCHAR));
    if (!info->working_dir)
        return E_OUTOFMEMORY;

@ -421,38 +421,21 @@ static HRESULT install_init(LPCWSTR inf_filename, LPCWSTR install_sec,
    if (!(ptr = wcsrchr(inf_filename, '\\')))
        ptr = inf_filename;

-    len = lstrlenW(ptr);
-
-    info->inf_filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
+    info->inf_filename = wcsdup(ptr);
    if (!info->inf_filename)
        return E_OUTOFMEMORY;

-    lstrcpyW(info->inf_filename, ptr);
-
    /* FIXME: determine the proper platform to install (NTx86, etc) */
-    if (!install_sec || !*install_sec)
-    {
-        len = ARRAY_SIZE(L"DefaultInstall");
-        ptr = L"DefaultInstall";
-    }
-    else
-    {
-        len = lstrlenW(install_sec) + 1;
-        ptr = install_sec;
-    }
-
-    info->install_sec = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+    info->install_sec = wcsdup(install_sec && *install_sec ? install_sec : L"DefaultInstall");
    if (!info->install_sec)
        return E_OUTOFMEMORY;

-    lstrcpyW(info->install_sec, ptr);
-
    hr = get_working_dir(info, inf_filename, working_dir);
    if (FAILED(hr))
        return hr;

    len = lstrlenW(info->working_dir) + lstrlenW(info->inf_filename) + 2;
-    info->inf_path = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+    info->inf_path = malloc(len * sizeof(WCHAR));
    if (!info->inf_path)
        return E_OUTOFMEMORY;

@ -485,10 +468,10 @@ static void install_release(const ADVInfo *info)
 {
    SetupCloseInfFile(info->hinf);

-    HeapFree(GetProcessHeap(), 0, info->inf_path);
-    HeapFree(GetProcessHeap(), 0, info->inf_filename);
-    HeapFree(GetProcessHeap(), 0, info->install_sec);
-    HeapFree(GetProcessHeap(), 0, info->working_dir);
+    free(info->inf_path);
+    free(info->inf_filename);
+    free(info->install_sec);
+    free(info->working_dir);
 }

 /* this structure very closely resembles parameters of RunSetupCommand() */
@ -533,7 +516,7 @@ static HRESULT DoInfInstallW(const SETUPCOMMAND_PARAMSW *setup)
 done:
    install_release(&info);

-    return S_OK;
+    return hr;
 }

 /***********************************************************************
@ -733,9 +716,8 @@ INT WINAPI LaunchINFSectionW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT sho
    if (!cmdline)
        return ADV_FAILURE;

-    cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
+    cmdline_copy = wcsdup(cmdline);
    cmdline_ptr = cmdline_copy;
-    lstrcpyW(cmdline_copy, cmdline);

    inf_filename = get_parameter(&cmdline_ptr, ',', TRUE);
    install_sec = get_parameter(&cmdline_ptr, ',', TRUE);
@ -762,7 +744,7 @@ INT WINAPI LaunchINFSectionW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT sho

 done:
    install_release(&info);
-    HeapFree(GetProcessHeap(), 0, cmdline_copy);
+    free(cmdline_copy);

    return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
 }
@ -830,9 +812,8 @@ HRESULT WINAPI LaunchINFSectionExW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, I
    if (!cmdline)
        return ADV_FAILURE;

-    cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
+    cmdline_copy = wcsdup(cmdline);
    cmdline_ptr = cmdline_copy;
-    lstrcpyW(cmdline_copy, cmdline);

    cabinfo.pszInf = get_parameter(&cmdline_ptr, ',', TRUE);
    cabinfo.pszSection = get_parameter(&cmdline_ptr, ',', TRUE);
@ -845,7 +826,7 @@ HRESULT WINAPI LaunchINFSectionExW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, I

    if (!is_full_path(cabinfo.pszCab) && !is_full_path(cabinfo.pszInf))
    {
-        HeapFree(GetProcessHeap(), 0, cmdline_copy);
+        free(cmdline_copy);
        return E_INVALIDARG;
    }

@ -862,7 +843,7 @@ HRESULT WINAPI LaunchINFSectionExW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, I
    }

    hr = ExecuteCabW(hWnd, &cabinfo, NULL);
-    HeapFree(GetProcessHeap(), 0, cmdline_copy);
+    free(cmdline_copy);
    return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
 }

--- a/dlls/advpack/reg.c
+++ b/dlls/advpack/reg.c
@ -95,8 +95,8 @@ static void strentry_atow(const STRENTRYA *aentry, STRENTRYW *wentry)
    name_len = MultiByteToWideChar(CP_ACP, 0, aentry->pszName, -1, NULL, 0);
    val_len = MultiByteToWideChar(CP_ACP, 0, aentry->pszValue, -1, NULL, 0);

-    wentry->pszName = HeapAlloc(GetProcessHeap(), 0, name_len * sizeof(WCHAR));
-    wentry->pszValue = HeapAlloc(GetProcessHeap(), 0, val_len * sizeof(WCHAR));
+    wentry->pszName = malloc(name_len * sizeof(WCHAR));
+    wentry->pszValue = malloc(val_len * sizeof(WCHAR));

    MultiByteToWideChar(CP_ACP, 0, aentry->pszName, -1, wentry->pszName, name_len);
    MultiByteToWideChar(CP_ACP, 0, aentry->pszValue, -1, wentry->pszValue, val_len);
@ -107,8 +107,8 @@ static STRTABLEW *strtable_atow(const STRTABLEA *atable)
    STRTABLEW *wtable;
    DWORD j;

-    wtable = HeapAlloc(GetProcessHeap(), 0, sizeof(STRTABLEW));
-    wtable->pse = HeapAlloc(GetProcessHeap(), 0, atable->cEntries * sizeof(STRENTRYW));
+    wtable = malloc(sizeof(STRTABLEW));
+    wtable->pse = malloc(atable->cEntries * sizeof(STRENTRYW));
    wtable->cEntries = atable->cEntries;

    for (j = 0; j < wtable->cEntries; j++)
@ -123,12 +123,12 @@ static void free_strtable(STRTABLEW *wtable)

    for (j = 0; j < wtable->cEntries; j++)
    {
-        HeapFree(GetProcessHeap(), 0, wtable->pse[j].pszName);
-        HeapFree(GetProcessHeap(), 0, wtable->pse[j].pszValue);
+        free(wtable->pse[j].pszName);
+        free(wtable->pse[j].pszValue);
    }

-    HeapFree(GetProcessHeap(), 0, wtable->pse);
-    HeapFree(GetProcessHeap(), 0, wtable);
+    free(wtable->pse);
+    free(wtable);
 }

 /***********************************************************************
--- a/dlls/advpack/tests/Makefile.in
+++ b/dlls/advpack/tests/Makefile.in
@ -1,7 +1,7 @@
 TESTDLL   = advpack.dll
 IMPORTS   = cabinet advapi32 advpack

-C_SRCS = \
+SOURCES = \
 	advpack.c \
 	files.c \
 	install.c
--- a/dlls/amsi/Makefile.in
+++ b/dlls/amsi/Makefile.in
@ -1,4 +1,4 @@
 MODULE    = amsi.dll

-C_SRCS = \
+SOURCES = \
 	main.c
--- a/dlls/amstream/Makefile.in
+++ b/dlls/amstream/Makefile.in
@ -1,14 +1,12 @@
 MODULE    = amstream.dll
 IMPORTS   = strmiids strmbase uuid ole32 advapi32 ddraw

-C_SRCS = \
+SOURCES = \
+	amstream_classes.idl \
 	audiodata.c \
 	audiostream.c \
 	ddrawstream.c \
 	filter.c \
 	main.c \
-	multimedia.c
-
-IDL_SRCS = amstream_classes.idl
-
-RC_SRCS = version.rc
+	multimedia.c \
+	version.rc
--- a/dlls/amstream/amstream_private.h
+++ b/dlls/amstream/amstream_private.h
@ -33,10 +33,10 @@
 #include "austream.h"
 #include "amstream.h"

-HRESULT multimedia_stream_create(IUnknown *outer, void **out) DECLSPEC_HIDDEN;
-HRESULT AMAudioData_create(IUnknown *pUnkOuter, LPVOID *ppObj) DECLSPEC_HIDDEN;
-HRESULT filter_create(IUnknown *outer, void **out) DECLSPEC_HIDDEN;
-HRESULT ddraw_stream_create(IUnknown *outer, void **out) DECLSPEC_HIDDEN;
-HRESULT audio_stream_create(IUnknown *outer, void **out) DECLSPEC_HIDDEN;
+HRESULT multimedia_stream_create(IUnknown *outer, void **out);
+HRESULT AMAudioData_create(IUnknown *pUnkOuter, LPVOID *ppObj);
+HRESULT filter_create(IUnknown *outer, void **out);
+HRESULT ddraw_stream_create(IUnknown *outer, void **out);
+HRESULT audio_stream_create(IUnknown *outer, void **out);

 #endif /* __AMSTREAM_PRIVATE_INCLUDED__ */
--- a/dlls/amstream/ddrawstream.c
+++ b/dlls/amstream/ddrawstream.c
@ -18,7 +18,6 @@
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

-#define NONAMELESSUNION
 #define COBJMACROS
 #include "amstream_private.h"
 #include "wine/debug.h"
@ -123,14 +122,14 @@ static HRESULT process_update(struct ddraw_sample *sample, int stride, BYTE *poi
    if (FAILED(hr))
        return hr;

-    row_size = (sample->rect.right - sample->rect.left) * desc.ddpfPixelFormat.u1.dwRGBBitCount / 8;
+    row_size = (sample->rect.right - sample->rect.left) * desc.ddpfPixelFormat.dwRGBBitCount / 8;
    src_row = pointer;
    dst_row = desc.lpSurface;
    for (row = sample->rect.top; row < sample->rect.bottom; ++row)
    {
        memcpy(dst_row, src_row, row_size);
        src_row += stride;
-        dst_row += desc.u1.lPitch;
+        dst_row += desc.lPitch;
    }

    hr = IDirectDrawSurface_Unlock(sample->surface, desc.lpSurface);
@ -155,9 +154,9 @@ static BOOL is_format_compatible(struct ddraw_stream *stream,
    {
        if (stream->format.pf.dwFlags & DDPF_FOURCC)
            return FALSE;
-        if (stream->format.pf.u1.dwRGBBitCount != connection_pf->u1.dwRGBBitCount)
+        if (stream->format.pf.dwRGBBitCount != connection_pf->dwRGBBitCount)
            return FALSE;
-        if (stream->format.pf.u1.dwRGBBitCount == 16 && stream->format.pf.u3.dwGBitMask != connection_pf->u3.dwGBitMask)
+        if (stream->format.pf.dwRGBBitCount == 16 && stream->format.pf.dwGBitMask != connection_pf->dwGBitMask)
            return FALSE;
    }
    return TRUE;
@ -325,6 +324,10 @@ static HRESULT WINAPI ddraw_IAMMediaStream_Initialize(IAMMediaStream *iface, IUn
    stream->purpose_id = *purpose_id;
    stream->stream_type = stream_type;

+    if (stream->ddraw)
+        IDirectDraw_Release(stream->ddraw);
+    stream->ddraw = NULL;
+
    if (source_object
            && FAILED(hr = IUnknown_QueryInterface(source_object, &IID_IDirectDraw, (void **)&stream->ddraw)))
        FIXME("Stream object doesn't implement IDirectDraw interface, hr %#lx.\n", hr);
@ -551,7 +554,7 @@ static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SetFormat(IDirectDrawMediaStr

    TRACE("flags %#lx, pixel format flags %#lx, bit count %lu, size %lux%lu.\n",
            format->dwFlags, format->ddpfPixelFormat.dwFlags,
-            format->ddpfPixelFormat.u1.dwRGBBitCount, format->dwWidth, format->dwHeight);
+            format->ddpfPixelFormat.dwRGBBitCount, format->dwWidth, format->dwHeight);

    if (format->dwFlags & DDSD_PIXELFORMAT)
    {
@ -560,7 +563,7 @@ static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SetFormat(IDirectDrawMediaStr

        if (format->ddpfPixelFormat.dwFlags & DDPF_FOURCC)
        {
-            if (!format->ddpfPixelFormat.u1.dwRGBBitCount)
+            if (!format->ddpfPixelFormat.dwRGBBitCount)
                return E_INVALIDARG;
        }
        else
@ -572,7 +575,7 @@ static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SetFormat(IDirectDrawMediaStr
            if (!(format->ddpfPixelFormat.dwFlags & DDPF_RGB))
                return DDERR_INVALIDSURFACETYPE;

-            switch (format->ddpfPixelFormat.u1.dwRGBBitCount)
+            switch (format->ddpfPixelFormat.dwRGBBitCount)
            {
            case 8:
                if (!(format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8))
@ -581,21 +584,21 @@ static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SetFormat(IDirectDrawMediaStr
            case 16:
                if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
                    return DDERR_INVALIDSURFACETYPE;
-                if ((format->ddpfPixelFormat.u2.dwRBitMask != 0x7c00 ||
-                    format->ddpfPixelFormat.u3.dwGBitMask != 0x03e0 ||
-                    format->ddpfPixelFormat.u4.dwBBitMask != 0x001f) &&
-                    (format->ddpfPixelFormat.u2.dwRBitMask != 0xf800 ||
-                    format->ddpfPixelFormat.u3.dwGBitMask != 0x07e0 ||
-                    format->ddpfPixelFormat.u4.dwBBitMask != 0x001f))
+                if ((format->ddpfPixelFormat.dwRBitMask != 0x7c00 ||
+                    format->ddpfPixelFormat.dwGBitMask != 0x03e0 ||
+                    format->ddpfPixelFormat.dwBBitMask != 0x001f) &&
+                    (format->ddpfPixelFormat.dwRBitMask != 0xf800 ||
+                    format->ddpfPixelFormat.dwGBitMask != 0x07e0 ||
+                    format->ddpfPixelFormat.dwBBitMask != 0x001f))
                    return DDERR_INVALIDSURFACETYPE;
                break;
            case 24:
            case 32:
                if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
                    return DDERR_INVALIDSURFACETYPE;
-                if (format->ddpfPixelFormat.u2.dwRBitMask != 0xff0000 ||
-                    format->ddpfPixelFormat.u3.dwGBitMask != 0x00ff00 ||
-                    format->ddpfPixelFormat.u4.dwBBitMask != 0x0000ff)
+                if (format->ddpfPixelFormat.dwRBitMask != 0xff0000 ||
+                    format->ddpfPixelFormat.dwGBitMask != 0x00ff00 ||
+                    format->ddpfPixelFormat.dwBBitMask != 0x0000ff)
                    return DDERR_INVALIDSURFACETYPE;
                break;
            default:
@ -958,35 +961,35 @@ static HRESULT WINAPI ddraw_sink_ReceiveConnection(IPin *iface, IPin *peer, cons
    if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB8))
    {
        pf.dwFlags |= DDPF_PALETTEINDEXED8;
-        pf.u1.dwRGBBitCount = 8;
+        pf.dwRGBBitCount = 8;
    }
    else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB555))
    {
-        pf.u1.dwRGBBitCount = 16;
-        pf.u2.dwRBitMask = 0x7c00;
-        pf.u3.dwGBitMask = 0x03e0;
-        pf.u4.dwBBitMask = 0x001f;
+        pf.dwRGBBitCount = 16;
+        pf.dwRBitMask = 0x7c00;
+        pf.dwGBitMask = 0x03e0;
+        pf.dwBBitMask = 0x001f;
    }
    else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB565))
    {
-        pf.u1.dwRGBBitCount = 16;
-        pf.u2.dwRBitMask = 0xf800;
-        pf.u3.dwGBitMask = 0x07e0;
-        pf.u4.dwBBitMask = 0x001f;
+        pf.dwRGBBitCount = 16;
+        pf.dwRBitMask = 0xf800;
+        pf.dwGBitMask = 0x07e0;
+        pf.dwBBitMask = 0x001f;
    }
    else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB24))
    {
-        pf.u1.dwRGBBitCount = 24;
-        pf.u2.dwRBitMask = 0xff0000;
-        pf.u3.dwGBitMask = 0x00ff00;
-        pf.u4.dwBBitMask = 0x0000ff;
+        pf.dwRGBBitCount = 24;
+        pf.dwRBitMask = 0xff0000;
+        pf.dwGBitMask = 0x00ff00;
+        pf.dwBBitMask = 0x0000ff;
    }
    else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB32))
    {
-        pf.u1.dwRGBBitCount = 32;
-        pf.u2.dwRBitMask = 0xff0000;
-        pf.u3.dwGBitMask = 0x00ff00;
-        pf.u4.dwBBitMask = 0x0000ff;
+        pf.dwRGBBitCount = 32;
+        pf.dwRBitMask = 0xff0000;
+        pf.dwGBitMask = 0x00ff00;
+        pf.dwBBitMask = 0x0000ff;
    }
    else
    {
@ -1406,6 +1409,7 @@ static HRESULT WINAPI ddraw_meminput_Receive(IMemInputPin *iface, IMediaSample *
        if (!list_empty(&stream->update_queue))
        {
            struct ddraw_sample *sample = LIST_ENTRY(list_head(&stream->update_queue), struct ddraw_sample, entry);
+            IQualityControl *qc;

            sample->update_hr = process_update(sample, top_down_stride, top_down_pointer,
                    start_stream_time, end_stream_time);
@ -1419,6 +1423,19 @@ static HRESULT WINAPI ddraw_meminput_Receive(IMemInputPin *iface, IMediaSample *
            {
                remove_queued_update(sample);
            }
+
+            if (S_OK == IMediaStreamFilter_GetCurrentStreamTime(filter, &current_time)
+                    && SUCCEEDED(IPin_QueryInterface(stream->peer, &IID_IQualityControl, (void **)&qc)))
+            {
+                Quality q;
+                q.Type = Famine;
+                q.Proportion = 1000;
+                q.Late = current_time - start_time;
+                q.TimeStamp = start_time;
+                IQualityControl_Notify(qc, (IBaseFilter *)stream->filter, q);
+                IQualityControl_Release(qc);
+            }
+
            LeaveCriticalSection(&stream->cs);
            return S_OK;
        }
@ -1776,11 +1793,11 @@ static HRESULT ddrawstreamsample_create(struct ddraw_stream *parent, IDirectDraw
        {
            desc.ddpfPixelFormat.dwSize = sizeof(desc.ddpfPixelFormat);
            desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
-            desc.ddpfPixelFormat.u1.dwRGBBitCount = 32;
-            desc.ddpfPixelFormat.u2.dwRBitMask = 0xff0000;
-            desc.ddpfPixelFormat.u3.dwGBitMask = 0x00ff00;
-            desc.ddpfPixelFormat.u4.dwBBitMask = 0x0000ff;
-            desc.ddpfPixelFormat.u5.dwRGBAlphaBitMask = 0;
+            desc.ddpfPixelFormat.dwRGBBitCount = 32;
+            desc.ddpfPixelFormat.dwRBitMask = 0xff0000;
+            desc.ddpfPixelFormat.dwGBitMask = 0x00ff00;
+            desc.ddpfPixelFormat.dwBBitMask = 0x0000ff;
+            desc.ddpfPixelFormat.dwRGBAlphaBitMask = 0;
        }
        desc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN;
        desc.lpSurface = NULL;
--- a/dlls/amstream/filter.c
+++ b/dlls/amstream/filter.c
@ -94,7 +94,7 @@ static HRESULT WINAPI enum_pins_Next(IEnumPins *iface, ULONG count, IPin **pins,

    for (i = 0; i < count && enum_pins->index < enum_pins->count; ++i)
    {
-        IPin_AddRef(pins[i] = enum_pins->pins[i]);
+        IPin_AddRef(pins[i] = enum_pins->pins[enum_pins->index]);
        enum_pins->index++;
    }

@ -254,6 +254,8 @@ static ULONG WINAPI filter_Release(IMediaStreamFilter *iface)
        free(filter->streams);
        if (filter->clock)
            IReferenceClock_Release(filter->clock);
+        if (filter->cs.DebugInfo)
+            filter->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&filter->cs);
        free(filter);
    }
@ -1100,7 +1102,7 @@ HRESULT filter_create(IUnknown *outer, void **out)
    object->refcount = 1;
    list_init(&object->free_events);
    list_init(&object->used_events);
-    InitializeCriticalSection(&object->cs);
+    InitializeCriticalSectionEx(&object->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MediaStreamFilter.cs");

    TRACE("Created media stream filter %p.\n", object);
--- a/dlls/amstream/tests/Makefile.in
+++ b/dlls/amstream/tests/Makefile.in
@ -1,8 +1,6 @@
 TESTDLL   = amstream.dll
 IMPORTS   = strmbase strmiids uuid ddraw ole32 user32

-C_SRCS = \
-	amstream.c
-
-RC_SRCS = \
+SOURCES = \
+	amstream.c \
 	rsrc.rc
--- a/dlls/amstream/tests/amstream.c
+++ b/dlls/amstream/tests/amstream.c
@ -386,6 +386,7 @@ static void test_interfaces(void)
    check_interface(stream, &IID_IMediaStreamFilter, FALSE);
    check_interface(stream, &IID_IMultiMediaStream, FALSE);
    check_interface(stream, &IID_IPersist, FALSE);
+    check_interface(stream, &IID_IQualityControl, FALSE);

    IMediaStream_Release(stream);

@ -408,6 +409,7 @@ static void test_interfaces(void)
    check_interface(stream, &IID_IMediaStreamFilter, FALSE);
    check_interface(stream, &IID_IMultiMediaStream, FALSE);
    check_interface(stream, &IID_IPersist, FALSE);
+    check_interface(stream, &IID_IQualityControl, FALSE);

    IMediaStream_Release(stream);

@ -1017,10 +1019,13 @@ struct testfilter
    struct strmbase_filter filter;
    struct strmbase_source source;
    IMediaSeeking IMediaSeeking_iface;
+    IQualityControl IQualityControl_iface;
    LONGLONG current_position;
    LONGLONG stop_position;
    const AM_MEDIA_TYPE *preferred_mt;
    HANDLE wait_state_event;
+    IBaseFilter *qc_notify_sender;
+    Quality qc_notify_quality;
    HRESULT get_duration_hr;
    HRESULT get_stop_position_hr;
    HRESULT set_positions_hr;
@ -1028,6 +1033,7 @@ struct testfilter
    HRESULT cleanup_stream_hr;
    HRESULT wait_state_hr;
    HRESULT is_format_supported_hr;
+    HRESULT qc_notify_hr;
 };

 static inline struct testfilter *impl_from_BaseFilter(struct strmbase_filter *iface)
@ -1123,6 +1129,8 @@ static HRESULT testsource_query_interface(struct strmbase_pin *iface, REFIID iid

    if (IsEqualGUID(iid, &IID_IMediaSeeking) && filter->IMediaSeeking_iface.lpVtbl)
        *out = &filter->IMediaSeeking_iface;
+    else if (IsEqualGUID(iid, &IID_IQualityControl) && filter->IQualityControl_iface.lpVtbl)
+        *out = &filter->IQualityControl_iface;
    else
        return E_NOINTERFACE;

@ -1358,6 +1366,54 @@ static const IMediaSeekingVtbl testsource_seeking_vtbl =
    testsource_seeking_GetPreroll,
 };

+static inline struct testfilter *impl_from_IQualityControl(IQualityControl *iface)
+{
+    return CONTAINING_RECORD(iface, struct testfilter, IQualityControl_iface);
+}
+
+static HRESULT WINAPI testsource_qc_QueryInterface(IQualityControl *iface, REFIID iid, void **out)
+{
+    struct testfilter *filter = impl_from_IQualityControl(iface);
+    return IBaseFilter_QueryInterface(&filter->filter.IBaseFilter_iface, iid, out);
+}
+
+static ULONG WINAPI testsource_qc_AddRef(IQualityControl *iface)
+{
+    struct testfilter *filter = impl_from_IQualityControl(iface);
+    return IBaseFilter_AddRef(&filter->filter.IBaseFilter_iface);
+}
+
+static ULONG WINAPI testsource_qc_Release(IQualityControl *iface)
+{
+    struct testfilter *filter = impl_from_IQualityControl(iface);
+    return IBaseFilter_Release(&filter->filter.IBaseFilter_iface);
+}
+
+static HRESULT WINAPI testsource_qc_Notify(IQualityControl *iface, IBaseFilter *sender, Quality q)
+{
+    struct testfilter *filter = impl_from_IQualityControl(iface);
+
+    filter->qc_notify_sender = sender;
+    filter->qc_notify_quality = q;
+
+    return filter->qc_notify_hr;
+}
+
+static HRESULT WINAPI testsource_qc_SetSink(IQualityControl *iface, IQualityControl *sink)
+{
+    ok(0, "Unexpected call.\n");
+    return E_NOTIMPL;
+}
+
+static const IQualityControlVtbl testsource_qc_vtbl =
+{
+    testsource_qc_QueryInterface,
+    testsource_qc_AddRef,
+    testsource_qc_Release,
+    testsource_qc_Notify,
+    testsource_qc_SetSink,
+};
+
 #define check_get_stream(a,b,c,d) check_get_stream_(__LINE__,a,b,c,d)
 static void check_get_stream_(int line, IAMMultiMediaStream *mmstream,
        IMediaStreamFilter *filter, const GUID *mspid, IMediaStream *expect)
@ -1839,10 +1895,10 @@ static void test_media_streams(void)
 static void test_enum_pins(void)
 {
    IAMMultiMediaStream *mmstream = create_ammultimediastream();
+    IMediaStream *stream0, *stream1;
+    IPin *pins[3], *pin0, *pin1;
    IMediaStreamFilter *filter;
    IEnumPins *enum1, *enum2;
-    IMediaStream *stream;
-    IPin *pins[3], *pin;
    ULONG ref, count;
    HRESULT hr;

@ -1877,9 +1933,13 @@ static void test_enum_pins(void)
    hr = IEnumPins_Skip(enum1, 1);
    ok(hr == S_FALSE, "Got hr %#lx.\n", hr);

-    hr = IAMMultiMediaStream_AddMediaStream(mmstream, NULL, &MSPID_PrimaryVideo, 0, &stream);
+    hr = IAMMultiMediaStream_AddMediaStream(mmstream, NULL, &MSPID_PrimaryVideo, 0, &stream0);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);
-    hr = IMediaStream_QueryInterface(stream, &IID_IPin, (void **)&pin);
+    hr = IAMMultiMediaStream_AddMediaStream(mmstream, NULL, &MSPID_PrimaryAudio, 0, &stream1);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    hr = IMediaStream_QueryInterface(stream0, &IID_IPin, (void **)&pin0);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    hr = IMediaStream_QueryInterface(stream1, &IID_IPin, (void **)&pin1);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);

    /* Reset() isn't enough; we have to call EnumPins() again to see the updated
@ -1899,17 +1959,30 @@ static void test_enum_pins(void)
    ok(ref == 4, "Got unexpected refcount %ld.\n", ref);
    ref = get_refcount(enum1);
    ok(ref == 1, "Got unexpected refcount %ld.\n", ref);
-    ref = get_refcount(pin);
+    ref = get_refcount(pin0);
+    ok(ref == 4, "Got unexpected refcount %ld.\n", ref);
+    ref = get_refcount(pin1);
    ok(ref == 4, "Got unexpected refcount %ld.\n", ref);

    hr = IEnumPins_Next(enum1, 1, pins, NULL);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);
-    ok(pins[0] == pin, "Expected pin %p, got %p.\n", pin, pins[0]);
+    ok(pins[0] == pin0, "Expected pin %p, got %p.\n", pin0, pins[0]);
    ref = get_refcount(filter);
    ok(ref == 4, "Got unexpected refcount %ld.\n", ref);
    ref = get_refcount(enum1);
    ok(ref == 1, "Got unexpected refcount %ld.\n", ref);
-    ref = get_refcount(pin);
+    ref = get_refcount(pin0);
+    ok(ref == 5, "Got unexpected refcount %ld.\n", ref);
+    IPin_Release(pins[0]);
+
+    hr = IEnumPins_Next(enum1, 1, pins, NULL);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    ok(pins[0] == pin1, "Expected pin %p, got %p.\n", pin1, pins[0]);
+    ref = get_refcount(filter);
+    ok(ref == 4, "Got unexpected refcount %ld.\n", ref);
+    ref = get_refcount(enum1);
+    ok(ref == 1, "Got unexpected refcount %ld.\n", ref);
+    ref = get_refcount(pin1);
    ok(ref == 5, "Got unexpected refcount %ld.\n", ref);
    IPin_Release(pins[0]);

@ -1922,20 +1995,28 @@ static void test_enum_pins(void)
    hr = IEnumPins_Next(enum1, 1, pins, &count);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);
    ok(count == 1, "Got count %lu.\n", count);
-    ok(pins[0] == pin, "Expected pin %p, got %p.\n", pin, pins[0]);
+    ok(pins[0] == pin0, "Expected pin %p, got %p.\n", pin0, pins[0]);
+    IPin_Release(pins[0]);
+
+    hr = IEnumPins_Next(enum1, 1, pins, &count);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    ok(count == 1, "Got count %lu.\n", count);
+    ok(pins[0] == pin1, "Expected pin %p, got %p.\n", pin1, pins[0]);
    IPin_Release(pins[0]);

    hr = IEnumPins_Reset(enum1);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);

-    hr = IEnumPins_Next(enum1, 2, pins, NULL);
+    hr = IEnumPins_Next(enum1, 3, pins, NULL);
    ok(hr == E_POINTER, "Got hr %#lx.\n", hr);

-    hr = IEnumPins_Next(enum1, 2, pins, &count);
+    hr = IEnumPins_Next(enum1, 3, pins, &count);
    ok(hr == S_FALSE, "Got hr %#lx.\n", hr);
-    ok(count == 1, "Got count %lu.\n", count);
-    ok(pins[0] == pin, "Expected pin %p, got %p.\n", pin, pins[0]);
+    ok(count == 2, "Got count %lu.\n", count);
+    ok(pins[0] == pin0, "Expected pin %p, got %p.\n", pin0, pins[0]);
+    ok(pins[1] == pin1, "Expected pin %p, got %p.\n", pin1, pins[1]);
    IPin_Release(pins[0]);
+    IPin_Release(pins[1]);

    hr = IEnumPins_Reset(enum1);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);
@ -1946,7 +2027,7 @@ static void test_enum_pins(void)
    hr = IEnumPins_Skip(enum1, 0);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);

-    hr = IEnumPins_Skip(enum1, 1);
+    hr = IEnumPins_Skip(enum1, 2);
    ok(hr == S_FALSE, "Got hr %#lx.\n", hr);

    hr = IEnumPins_Next(enum1, 1, pins, NULL);
@ -1954,7 +2035,12 @@ static void test_enum_pins(void)

    hr = IEnumPins_Next(enum2, 1, pins, NULL);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);
-    ok(pins[0] == pin, "Expected pin %p, got %p.\n", pin, pins[0]);
+    ok(pins[0] == pin0, "Expected pin %p, got %p.\n", pin0, pins[0]);
+    IPin_Release(pins[0]);
+
+    hr = IEnumPins_Next(enum2, 1, pins, NULL);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    ok(pins[0] == pin1, "Expected pin %p, got %p.\n", pin1, pins[0]);
    IPin_Release(pins[0]);

    IEnumPins_Release(enum2);
@ -1963,8 +2049,11 @@ static void test_enum_pins(void)
    IMediaStreamFilter_Release(filter);
    ref = IAMMultiMediaStream_Release(mmstream);
    ok(!ref, "Got outstanding refcount %ld.\n", ref);
-    IMediaStream_Release(stream);
-    ref = IPin_Release(pin);
+    IMediaStream_Release(stream1);
+    IMediaStream_Release(stream0);
+    ref = IPin_Release(pin1);
+    ok(!ref, "Got outstanding refcount %ld.\n", ref);
+    ref = IPin_Release(pin0);
    ok(!ref, "Got outstanding refcount %ld.\n", ref);
 }

@ -5991,6 +6080,9 @@ static void test_ddrawstream_begin_flush_end_flush(void)
    IDirectDrawMediaStream_Release(ddraw_stream);
    ref = IMediaStream_Release(stream);
    ok(!ref, "Got outstanding refcount %ld.\n", ref);
+    IPin_Release(pin2);
+    ref = IAMMediaStream_Release(stream2);
+    ok(!ref, "Got outstanding refcount %ld.\n", ref);
 }

 static void test_ddrawstream_new_segment(void)
@ -8154,6 +8246,244 @@ static void test_ddrawstream_create_sample(void)
            desc.ddckCKSrcBlt.dwColorSpaceHighValue);
 }

+static void test_ddrawstream_qc(void)
+{
+    static const BYTE test_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+    IAMMultiMediaStream *mmstream = create_ammultimediastream();
+    struct advise_time_cookie cookie = { 0 };
+    IDirectDrawStreamSample *stream_sample;
+    IDirectDrawMediaStream *ddraw_stream;
+    IMediaFilter *graph_media_filter;
+    STREAM_TIME filter_start_time;
+    IMemInputPin *mem_input_pin;
+    IMediaStreamFilter *filter;
+    struct testfilter source;
+    struct testclock clock;
+    STREAM_TIME start_time;
+    STREAM_TIME end_time;
+    IGraphBuilder *graph;
+    IMediaStream *stream;
+    VIDEOINFO video_info;
+    AM_MEDIA_TYPE mt;
+    HANDLE thread;
+    HRESULT hr;
+    ULONG ref;
+    IPin *pin;
+
+    hr = IAMMultiMediaStream_Initialize(mmstream, STREAMTYPE_READ, 0, NULL);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    hr = IAMMultiMediaStream_GetFilter(mmstream, &filter);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    ok(!!filter, "Expected non-null filter.\n");
+    hr = IAMMultiMediaStream_AddMediaStream(mmstream, NULL, &MSPID_PrimaryVideo, 0, &stream);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    hr = IMediaStream_QueryInterface(stream, &IID_IDirectDrawMediaStream, (void **)&ddraw_stream);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    hr = IMediaStream_QueryInterface(stream, &IID_IPin, (void **)&pin);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    hr = IMediaStream_QueryInterface(stream, &IID_IMemInputPin, (void **)&mem_input_pin);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    hr = IAMMultiMediaStream_GetFilterGraph(mmstream, &graph);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    ok(graph != NULL, "Expected non-NULL graph.\n");
+    hr = IGraphBuilder_QueryInterface(graph, &IID_IMediaFilter, (void **)&graph_media_filter);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    testfilter_init(&source);
+    source.IQualityControl_iface.lpVtbl = &testsource_qc_vtbl;
+    hr = IGraphBuilder_AddFilter(graph, &source.filter.IBaseFilter_iface, NULL);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    testclock_init(&clock);
+    cookie.advise_time_called_event = CreateEventW(NULL, FALSE, FALSE, NULL);
+    ok(cookie.advise_time_called_event != NULL, "Expected non-NULL event.");
+
+    video_info = rgb32_video_info;
+    video_info.bmiHeader.biWidth = 3;
+    video_info.bmiHeader.biHeight = 1;
+    mt = rgb32_mt;
+    mt.pbFormat = (BYTE *)&video_info;
+    hr = IGraphBuilder_ConnectDirect(graph, &source.source.pin.IPin_iface, pin, &mt);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    hr = IDirectDrawMediaStream_CreateSample(ddraw_stream, NULL, NULL, 0, &stream_sample);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    /* There are no quality control messages without a sync source. */
+    hr = IMediaFilter_SetSyncSource(graph_media_filter, NULL);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    hr = IAMMultiMediaStream_SetState(mmstream, STREAMSTATE_RUN);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    source.qc_notify_sender = (IBaseFilter *)0xdeadbeef;
+    source.qc_notify_quality.Type = Flood;
+    source.qc_notify_quality.Proportion = 0xdeadbeef;
+    source.qc_notify_quality.Late = 0xdeadbeef;
+    source.qc_notify_quality.TimeStamp = 0xdeadbeef;
+
+    thread = ammediastream_async_receive_time(&source,
+            11111111, 11111111, test_data, sizeof(test_data));
+    ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Receive returned prematurely.\n");
+
+    hr = IDirectDrawStreamSample_Update(stream_sample, 0, NULL, NULL, 0);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    ok(!WaitForSingleObject(thread, 2000), "Wait timed out.\n");
+    CloseHandle(thread);
+
+    ok(source.qc_notify_sender == (IBaseFilter *)0xdeadbeef, "Got sender %p.\n",
+            source.qc_notify_sender);
+    ok(source.qc_notify_quality.Type == Flood, "Got type %d.\n",
+            source.qc_notify_quality.Type);
+    ok(source.qc_notify_quality.Proportion == 0xdeadbeef, "Got proportion %ld.\n",
+            source.qc_notify_quality.Proportion);
+    ok(source.qc_notify_quality.Late == 0xdeadbeef,
+            "Got late %s.\n", wine_dbgstr_longlong(source.qc_notify_quality.Late));
+    ok(source.qc_notify_quality.TimeStamp == 0xdeadbeef, "Got time stamp %s.\n",
+            wine_dbgstr_longlong(source.qc_notify_quality.TimeStamp));
+
+    hr = IAMMultiMediaStream_SetState(mmstream, STREAMSTATE_STOP);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    hr = IMediaFilter_SetSyncSource(graph_media_filter, &clock.IReferenceClock_iface);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    clock.time = 12345678;
+
+    hr = IAMMultiMediaStream_SetState(mmstream, STREAMSTATE_RUN);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    hr = IMediaStreamFilter_GetCurrentStreamTime(filter, &filter_start_time);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    /* Quality control message is sent on update completion, q.Late is computed
+     * as a difference between sample start time and update completion time. */
+
+    /* Test Update() before Reveive(). */
+    source.qc_notify_sender = (IBaseFilter *)0xdeadbeef;
+    source.qc_notify_quality.Type = Flood;
+    source.qc_notify_quality.Proportion = 0xdeadbeef;
+    source.qc_notify_quality.Late = 0xdeadbeef;
+    source.qc_notify_quality.TimeStamp = 0xdeadbeef;
+
+    clock.time = 12345678 - filter_start_time + 11111111;
+
+    hr = IDirectDrawStreamSample_Update(stream_sample, SSUPDATE_ASYNC, NULL, NULL, 0);
+    ok(hr == MS_S_PENDING, "Got hr %#lx.\n", hr);
+
+    clock.advise_time_cookie = &cookie;
+    clock.time = 12345678 - filter_start_time + 11111111 + 100000;
+
+    start_time = 11111111 + 200000;
+    end_time = 11111111 + 200000;
+    thread = ammediastream_async_receive_time(&source,
+            start_time, end_time, test_data, sizeof(test_data));
+    ok(!WaitForSingleObject(cookie.advise_time_called_event, 2000), "Wait timed out.\n");
+
+    ok(source.qc_notify_sender == (IBaseFilter *)0xdeadbeef, "Got sender %p.\n",
+            source.qc_notify_sender);
+    ok(source.qc_notify_quality.Type == Flood, "Got type %d.\n",
+            source.qc_notify_quality.Type);
+    ok(source.qc_notify_quality.Proportion == 0xdeadbeef, "Got proportion %ld.\n",
+            source.qc_notify_quality.Proportion);
+    ok(source.qc_notify_quality.Late == 0xdeadbeef,
+            "Got late %s.\n", wine_dbgstr_longlong(source.qc_notify_quality.Late));
+    ok(source.qc_notify_quality.TimeStamp == 0xdeadbeef, "Got time stamp %s.\n",
+            wine_dbgstr_longlong(source.qc_notify_quality.TimeStamp));
+
+    clock.time = 12345678 - filter_start_time + 11111111 + 200000;
+
+    SetEvent(cookie.event);
+
+    ok(!WaitForSingleObject(thread, 2000), "Wait timed out.\n");
+    CloseHandle(thread);
+
+    hr = IDirectDrawStreamSample_CompletionStatus(stream_sample, 0, 0);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    ok(source.qc_notify_sender == (IBaseFilter *)filter, "Got sender %p.\n",
+            source.qc_notify_sender);
+    ok(source.qc_notify_quality.Type == Famine, "Got type %d.\n",
+            source.qc_notify_quality.Type);
+    ok(source.qc_notify_quality.Proportion == 1000, "Got proportion %ld.\n",
+            source.qc_notify_quality.Proportion);
+    ok(source.qc_notify_quality.Late == 0, "Got late %s.\n",
+            wine_dbgstr_longlong(source.qc_notify_quality.Late));
+    ok(source.qc_notify_quality.TimeStamp == start_time, "Got time stamp %s.\n",
+            wine_dbgstr_longlong(source.qc_notify_quality.TimeStamp));
+
+    /* Test Update() after Reveive(). */
+    source.qc_notify_sender = (IBaseFilter *)0xdeadbeef;
+    source.qc_notify_quality.Type = Flood;
+    source.qc_notify_quality.Proportion = 0xdeadbeef;
+    source.qc_notify_quality.Late = 0xdeadbeef;
+    source.qc_notify_quality.TimeStamp = 0xdeadbeef;
+
+    clock.advise_time_cookie = &cookie;
+    clock.time = 12345678 - filter_start_time + 11111111 + 300000;
+
+    start_time = 11111111 + 400000;
+    end_time = 11111111 + 400000;
+    thread = ammediastream_async_receive_time(&source,
+            start_time, end_time, test_data, sizeof(test_data));
+    ok(!WaitForSingleObject(cookie.advise_time_called_event, 2000), "Wait timed out.\n");
+
+    clock.time = 12345678 - filter_start_time + 11111111 + 400000;
+    SetEvent(cookie.event);
+
+    ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Receive returned prematurely.\n");
+
+    ok(source.qc_notify_sender == (IBaseFilter *)0xdeadbeef, "Got sender %p.\n",
+            source.qc_notify_sender);
+    ok(source.qc_notify_quality.Type == Flood, "Got type %d.\n",
+            source.qc_notify_quality.Type);
+    ok(source.qc_notify_quality.Proportion == 0xdeadbeef, "Got proportion %ld.\n",
+            source.qc_notify_quality.Proportion);
+    ok(source.qc_notify_quality.Late == 0xdeadbeef,
+            "Got late %s.\n", wine_dbgstr_longlong(source.qc_notify_quality.Late));
+    ok(source.qc_notify_quality.TimeStamp == 0xdeadbeef, "Got time stamp %s.\n",
+            wine_dbgstr_longlong(source.qc_notify_quality.TimeStamp));
+
+    clock.time = 12345678 - filter_start_time + 11111111 + 500000;
+
+    hr = IDirectDrawStreamSample_Update(stream_sample, 0, NULL, NULL, 0);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+    ok(!WaitForSingleObject(thread, 2000), "Wait timed out.\n");
+    CloseHandle(thread);
+
+    ok(source.qc_notify_sender == (IBaseFilter *)filter, "Got sender %p.\n",
+            source.qc_notify_sender);
+    ok(source.qc_notify_quality.Type == Famine, "Got type %d.\n",
+            source.qc_notify_quality.Type);
+    ok(source.qc_notify_quality.Proportion == 1000, "Got proportion %ld.\n",
+            source.qc_notify_quality.Proportion);
+    ok(source.qc_notify_quality.Late == 100000, "Got late %s.\n",
+            wine_dbgstr_longlong(source.qc_notify_quality.Late));
+    ok(source.qc_notify_quality.TimeStamp == start_time, "Got time stamp %s.\n",
+            wine_dbgstr_longlong(source.qc_notify_quality.TimeStamp));
+
+    hr = IAMMultiMediaStream_SetState(mmstream, STREAMSTATE_STOP);
+    ok(hr == S_OK, "Got hr %#lx.\n", hr);
+    IGraphBuilder_Disconnect(graph, pin);
+    IGraphBuilder_Disconnect(graph, &source.source.pin.IPin_iface);
+
+    CloseHandle(cookie.advise_time_called_event);
+    ref = IDirectDrawStreamSample_Release(stream_sample);
+    ok(!ref, "Got outstanding refcount %ld.\n", ref);
+    ref = IAMMultiMediaStream_Release(mmstream);
+    ok(!ref, "Got outstanding refcount %ld.\n", ref);
+    IMediaFilter_Release(graph_media_filter);
+    ref = IGraphBuilder_Release(graph);
+    ok(!ref, "Got outstanding refcount %ld.\n", ref);
+    ref = IMediaStreamFilter_Release(filter);
+    ok(!ref, "Got outstanding refcount %ld.\n", ref);
+    IPin_Release(pin);
+    IMemInputPin_Release(mem_input_pin);
+    IDirectDrawMediaStream_Release(ddraw_stream);
+    ref = IMediaStream_Release(stream);
+    ok(!ref, "Got outstanding refcount %ld.\n", ref);
+}
+
 static void test_ddrawstreamsample_get_media_stream(void)
 {
    IAMMultiMediaStream *mmstream = create_ammultimediastream();
@ -9480,6 +9810,7 @@ START_TEST(amstream)
    test_ddrawstream_begin_flush_end_flush();
    test_ddrawstream_new_segment();
    test_ddrawstream_get_time_per_frame();
+    test_ddrawstream_qc();

    test_ddrawstreamsample_get_media_stream();
    test_ddrawstreamsample_update();
--- a/dlls/apisetschema/Makefile.in
+++ b/dlls/apisetschema/Makefile.in
@ -1,3 +1,6 @@
 MODULE    = apisetschema.dll

 EXTRADLLFLAGS = -Wb,--data-only
+
+SOURCES = \
+	apisetschema.spec
--- a/dlls/apisetschema/apisetschema.spec
+++ b/dlls/apisetschema/apisetschema.spec
@ -9,6 +9,7 @@ apiset api-ms-win-core-atoms-l1-1-0 = kernel32.dll
 apiset api-ms-win-core-backgroundtask-l1-1-0 = kernelbase.dll
 apiset api-ms-win-core-calendar-l1-1-0 = kernel32.dll
 apiset api-ms-win-core-com-l1-1-1 = combase.dll
+apiset api-ms-win-core-com-l2-1-1 = coml2.dll
 apiset api-ms-win-core-com-midlproxystub-l1-1-0 = combase.dll
 apiset api-ms-win-core-com-private-l1-1-0 = combase.dll
 apiset api-ms-win-core-com-private-l1-2-0 = combase.dll
@ -99,6 +100,7 @@ apiset api-ms-win-core-psapi-ansi-l1-1-0 = kernelbase.dll
 apiset api-ms-win-core-psapi-l1-1-0 = kernelbase.dll
 apiset api-ms-win-core-psapi-obsolete-l1-1-0 = kernelbase.dll
 apiset api-ms-win-core-psapiansi-l1-1-0 = kernelbase.dll
+apiset api-ms-win-core-psm-appnotify-l1-1-0 = twinapi.appcore.dll
 apiset api-ms-win-core-psm-key-l1-1-1 = kernelbase.dll
 apiset api-ms-win-core-quirks-l1-1-0 = kernelbase.dll
 apiset api-ms-win-core-realtime-l1-1-0 = kernelbase.dll
@ -340,9 +342,12 @@ apiset ext-ms-win-drvinst-desktop-l1-1-0 = newdev.dll
 apiset ext-ms-win-dwmapi-ext-l1-1-0 = dwmapi.dll
 apiset ext-ms-win-dwmapidxgi-ext-l1-1-1 = dwmapi.dll
 apiset ext-ms-win-dx-d3d9-l1-1-0 = d3d9.dll
+apiset ext-ms-win-dx-d3dkmt-dxcore-l1-1-3 = dxcore.dll
 apiset ext-ms-win-dx-d3dkmt-gdi-l1-1-0 = gdi32.dll
 apiset ext-ms-win-dx-ddraw-l1-1-0 = ddraw.dll
 apiset ext-ms-win-dx-dinput8-l1-1-0 = dinput8.dll
+apiset ext-ms-win-dxcore-internal-l1-1-0 = dxcore.dll
+apiset ext-ms-win-dxcore-l1-1-0 = dxcore.dll
 apiset ext-ms-win-eventing-pdh-l1-1-2 = pdh.dll
 apiset ext-ms-win-eventing-tdh-ext-l1-1-0 = tdh.dll
 apiset ext-ms-win-eventing-tdh-priv-l1-1-0 = tdh.dll
--- a/dlls/apphelp/Makefile.in
+++ b/dlls/apphelp/Makefile.in
@ -2,4 +2,5 @@ MODULE = apphelp.dll

 EXTRADLLFLAGS = -Wb,--prefer-native

-C_SRCS = apphelp.c
+SOURCES = \
+	apphelp.c
--- a/dlls/apphelp/tests/Makefile.in
+++ b/dlls/apphelp/tests/Makefile.in
@ -1,5 +1,5 @@
 TESTDLL   = apphelp.dll
 IMPORTS   = ole32

-C_SRCS = \
+SOURCES = \
 	apphelp.c
--- a/dlls/appwiz.cpl/Makefile.in
+++ b/dlls/appwiz.cpl/Makefile.in
@ -2,13 +2,10 @@ MODULE    = appwiz.cpl
 IMPORTS   = uuid urlmon advpack comctl32 advapi32 shell32 ole32 user32 comdlg32 bcrypt kernelbase
 DELAYIMPORTS = msi

-C_SRCS = \
+SOURCES = \
 	addons.c \
-	appwiz.c
-
-RC_SRCS = appwiz.rc
-
-SVG_SRCS = \
+	appwiz.c \
+	appwiz.rc \
 	appwiz.svg

 addons_EXTRADEFS = -DINSTALL_DATADIR="\"${datadir}\""
--- a/dlls/appwiz.cpl/addons.c
+++ b/dlls/appwiz.cpl/addons.c
@ -22,8 +22,6 @@
 #include <errno.h>

 #define COBJMACROS
-#define NONAMELESSUNION
-
 #include "windef.h"
 #include "winbase.h"
 #include "winuser.h"
@ -46,22 +44,22 @@

 WINE_DEFAULT_DEBUG_CHANNEL(appwizcpl);

-#define GECKO_VERSION "2.47.3"
+#define GECKO_VERSION "2.47.4"
 #ifdef __i386__
 #define GECKO_ARCH "x86"
-#define GECKO_SHA "e5b9b06d3ce355646a8d2e72e044e37e1e0c8d18464eb1985adcd187a7f48e01"
+#define GECKO_SHA "26cecc47706b091908f7f814bddb074c61beb8063318e9efc5a7f789857793d6"
 #elif defined(__x86_64__)
 #define GECKO_ARCH "x86_64"
-#define GECKO_SHA "a53ee954392b6d1fe3d68545f6e4e2a97afbc8dc8b03a8b443349545ce139675"
+#define GECKO_SHA "e590b7d988a32d6aa4cf1d8aa3aa3d33766fdd4cf4c89c2dcc2095ecb28d066f"
 #else
 #define GECKO_ARCH ""
 #define GECKO_SHA "???"
 #endif

-#define MONO_VERSION "7.4.0"
+#define MONO_VERSION "9.0.0"
 #if defined(__i386__) || defined(__x86_64__)
 #define MONO_ARCH "x86"
-#define MONO_SHA "6413ff328ebbf7ec7689c648feb3546d8102ded865079d1fbf0331b14b3ab0ec"
+#define MONO_SHA "79f6c43100675566c112f4199b9ea7b944d338164b34bd91fa11b0b0a414e1c4"
 #else
 #define MONO_ARCH ""
 #define MONO_SHA "???"
@ -110,8 +108,7 @@ static LPWSTR url = NULL;
 static IBinding *dwl_binding;
 static WCHAR *msi_file;

-extern const char * CDECL wine_get_version(void);
-
+static const char * (CDECL *p_wine_get_version)(void);
 static WCHAR * (CDECL *p_wine_get_dos_file_name)(const char*);

 static BOOL sha_check(const WCHAR *file_name)
@ -518,7 +515,7 @@ static HRESULT WINAPI InstallCallback_OnDataAvailable(IBindStatusCallback *iface
        DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
 {
    if(!msi_file) {
-        msi_file = wcsdup(pstgmed->u.lpszFileName);
+        msi_file = wcsdup(pstgmed->lpszFileName);
        TRACE("got file name %s\n", debugstr_w(msi_file));
    }

@ -612,7 +609,7 @@ static void append_url_params( WCHAR *url )
    len += MultiByteToWideChar(CP_ACP, 0, addon->version, -1, url+len, size/sizeof(WCHAR)-len)-1;
    lstrcpyW(url+len, L"&winev=");
    len += lstrlenW(L"&winev=");
-    MultiByteToWideChar(CP_ACP, 0, wine_get_version(), -1, url+len, size/sizeof(WCHAR)-len);
+    MultiByteToWideChar(CP_ACP, 0, p_wine_get_version() ? p_wine_get_version() : 0, -1, url+len, size/sizeof(WCHAR)-len);
 }

 static LPWSTR get_url(void)
@ -753,6 +750,7 @@ BOOL install_addon(addon_t addon_type)
    addon = addons_info+addon_type;

    p_wine_get_dos_file_name = (void *)GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "wine_get_dos_file_name");
+    p_wine_get_version = (void *)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "wine_get_version");

    /*
     * Try to find addon .msi file in following order:
--- a/dlls/appwiz.cpl/appwiz.c
+++ b/dlls/appwiz.cpl/appwiz.c
@ -23,8 +23,6 @@
 *
 */

-#define NONAMELESSUNION
-
 #include <string.h>
 #include <stdlib.h>
 #include <stdarg.h>
@ -454,13 +452,7 @@ static void InstallProgram(HWND hWnd)
    }
 }

-/******************************************************************************
- * Name       : UninstallProgram
- * Description: Executes the specified program's installer.
- * Parameters : id      - the internal ID of the installer to remove
- * Parameters : button  - ID of button pressed (Modify or Remove)
- */
-static void UninstallProgram(int id, DWORD button)
+static HANDLE run_uninstaller(int id, DWORD button)
 {
    APPINFO *iter;
    STARTUPINFOW si;
@ -489,10 +481,7 @@ static void UninstallProgram(int id, DWORD button)
            if (res)
            {
                CloseHandle(info.hThread);
-
-                /* wait for the process to exit */
-                WaitForSingleObject(info.hProcess, INFINITE);
-                CloseHandle(info.hProcess);
+                return info.hProcess;
            }
            else
            {
@ -510,6 +499,8 @@ static void UninstallProgram(int id, DWORD button)
            break;
        }
    }
+
+    return NULL;
 }

 /**********************************************************************************
@ -615,9 +606,14 @@ static INT_PTR CALLBACK SupportInfoDlgProc(HWND hWnd, UINT msg, WPARAM wParam, L
        case WM_DESTROY:
            return 0;

+        case WM_CLOSE:
+            EndDialog(hWnd, TRUE);
+            return TRUE;
+
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
+                case IDCANCEL:
                case IDOK:
                    EndDialog(hWnd, TRUE);
                    break;
@ -781,6 +777,7 @@ static HIMAGELIST ResetApplicationList(BOOL bFirstRun, HWND hWnd, HIMAGELIST hIm
 static INT_PTR CALLBACK MainDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
    int selitem;
+    static HANDLE uninstaller = NULL;
    static HIMAGELIST hImageList;
    LPNMHDR nmh;
    LVITEMW lvItem;
@ -832,6 +829,16 @@ static INT_PTR CALLBACK MainDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM l

                case IDC_ADDREMOVE:
                case IDC_MODIFY:
+                    if (uninstaller)
+                    {
+                        WCHAR titleW[MAX_STRING_LEN], wait_tip[MAX_STRING_LEN];
+
+                        LoadStringW(hInst, IDS_CPL_TITLE, titleW, ARRAY_SIZE(titleW));
+                        LoadStringW(hInst, IDS_WAIT_COMPLETE, wait_tip, ARRAY_SIZE(wait_tip));
+                        MessageBoxW(hWnd, wait_tip, titleW, MB_OK | MB_ICONWARNING);
+                        break;
+                    }
+
                    selitem = SendDlgItemMessageW(hWnd, IDL_PROGRAMS,
                        LVM_GETNEXTITEM, -1, LVNI_FOCUSED|LVNI_SELECTED);

@ -840,9 +847,22 @@ static INT_PTR CALLBACK MainDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM l
                        lvItem.iItem = selitem;
                        lvItem.mask = LVIF_PARAM;

-                        if (SendDlgItemMessageW(hWnd, IDL_PROGRAMS, LVM_GETITEMW,
-                          0, (LPARAM) &lvItem))
-                            UninstallProgram(lvItem.lParam, LOWORD(wParam));
+                        if (SendDlgItemMessageW(hWnd, IDL_PROGRAMS, LVM_GETITEMW, 0, (LPARAM)&lvItem))
+                        {
+                            uninstaller = run_uninstaller(lvItem.lParam, LOWORD(wParam));
+                            while (MsgWaitForMultipleObjects(1, &uninstaller, FALSE, INFINITE, QS_ALLINPUT) == 1)
+                            {
+                                MSG message;
+
+                                while (PeekMessageW(&message, 0, 0, 0, PM_REMOVE))
+                                {
+                                    TranslateMessage(&message);
+                                    DispatchMessageW(&message);
+                                }
+                            }
+                            CloseHandle(uninstaller);
+                            uninstaller = NULL;
+                        }
                    }

                    hImageList = ResetApplicationList(FALSE, hWnd, hImageList);
@ -904,8 +924,8 @@ static void StartApplet(HWND hWnd)
    psp.dwSize = sizeof (PROPSHEETPAGEW);
    psp.dwFlags = PSP_USETITLE;
    psp.hInstance = hInst;
-    psp.u.pszTemplate = MAKEINTRESOURCEW (IDD_MAIN);
-    psp.u2.pszIcon = NULL;
+    psp.pszTemplate = MAKEINTRESOURCEW (IDD_MAIN);
+    psp.pszIcon = NULL;
    psp.pfnDlgProc = MainDlgProc;
    psp.pszTitle = tab_title;
    psp.lParam = 0;
@ -915,12 +935,12 @@ static void StartApplet(HWND hWnd)
    psh.dwFlags = PSH_PROPSHEETPAGE | PSH_USEICONID | PSH_USECALLBACK;
    psh.hwndParent = hWnd;
    psh.hInstance = hInst;
-    psh.u.pszIcon = MAKEINTRESOURCEW(ICO_MAIN);
+    psh.pszIcon = MAKEINTRESOURCEW(ICO_MAIN);
    psh.pszCaption = app_title;
    psh.nPages = 1;
-    psh.u3.ppsp = &psp;
+    psh.ppsp = &psp;
    psh.pfnCallback = propsheet_callback;
-    psh.u2.nStartPage = 0;
+    psh.nStartPage = 0;

    /* Display the property sheet */
    PropertySheetW (&psh);
--- a/dlls/appwiz.cpl/appwiz.h
+++ b/dlls/appwiz.cpl/appwiz.h
@ -23,9 +23,9 @@ typedef enum {
    ADDON_MONO
 } addon_t;

-BOOL install_addon(addon_t) DECLSPEC_HIDDEN;
+BOOL install_addon(addon_t);

-extern HINSTANCE hInst DECLSPEC_HIDDEN;
+extern HINSTANCE hInst;

 static inline WCHAR *strdupAtoW(const char *str)
 {
--- a/dlls/appwiz.cpl/appwiz.rc
+++ b/dlls/appwiz.cpl/appwiz.rc
@ -43,6 +43,7 @@ STRINGTABLE

   IDS_REMOVE, "&Remove"
   IDS_MODIFY_REMOVE, "&Modify/Remove"
+   IDS_WAIT_COMPLETE, "Please wait until the current uninstall/modify process is complete."
 }

 STRINGTABLE
--- a/dlls/appwiz.cpl/res.h
+++ b/dlls/appwiz.cpl/res.h
@ -72,3 +72,4 @@
 #define IDS_DOWNLOADING        14
 #define IDS_INSTALLING         15
 #define IDS_INVALID_SHA        16
+#define IDS_WAIT_COMPLETE      17
--- a/dlls/appxdeploymentclient/Makefile.in
+++ b/dlls/appxdeploymentclient/Makefile.in
@ -0,0 +1,7 @@
+MODULE  = appxdeploymentclient.dll
+IMPORTS = combase
+
+SOURCES = \
+	classes.idl \
+	main.c \
+	package.c
--- a/dlls/appxdeploymentclient/appxdeploymentclient.spec
+++ b/dlls/appxdeploymentclient/appxdeploymentclient.spec
@ -0,0 +1,82 @@
+1 stub @
+@ stub GetApplicability
+@ stub AppxCreateSharedLocalFolder
+@ stub AppxPackageRepositoryRecoverStagedPackages
+@ stub AppxPackageRepositoryRecoverUserInstalls
+@ stub AppxRecoverUserInstallsForUpgrade
+@ stub AppxDeletePackageFiles
+@ stub AppxRequestRemovePackageForUser
+@ stub IsPackageInstalled
+@ stub RDSRecoverRequests
+@ stub AppxPreStageCleanupRunTask
+@ stub AppxPreRegisterPackage
+@ stub ReArmAppxPreStageCleanupTask
+@ stub AppxAddPackageToAllUserStoreForPbr
+@ stub GetPackageApplicabilityForUserLogon
+16 stub @
+@ stub AppxStagePackage
+@ stub AppxGetPackageInstalledLocation
+@ stub AppxDestagePackage
+@ stub GetApplicability2
+@ stub AppxGetStagedPackageFullNameFromFamilyName
+@ stub AppxIsStagedPackageStoreSigned
+@ stub RegisterNotification
+@ stub UnregisterNotification
+@ stub GetNotificationPayload
+@ stub NotifyPackageStatusChanged
+@ stub VerifyPackage
+@ stub AppxPreRegisterAllInboxPackages
+@ stub AppxValidatePackagesWithOptions
+@ stub AppxRemovePackageForAllUsers
+@ stub RequestContentGroups
+@ stub GetApplicability4
+@ stub RequestContentGroupsForFullTrust
+@ stub GeneratePreInstalledPriFiles
+@ stub PopulateProtocolAndFTA
+@ stub FixJunctionsForAppsIfNecessary
+@ stub AppxRemovePackageForUserSid
+@ stub CreateCanonicalPriFile
+@ stub RegisterNotificationForUser
+@ stub UnregisterNotificationForUser
+@ stub GetNotificationPayloadForUser
+@ stub AppxCleanupWCIReparsePoints
+@ stub RepairPackageFileAcls
+@ stub EnsurePackageFamilyIsRegisteredBeforeActivation
+@ stub AppxCleanupSystemAppsMigratedToFOD
+@ stub AppxCleanupOrphanPackages
+@ stub CheckComCallerHasCapabilities
+@ stub GetBundleApplicablePackages
+@ stub GetApplicability5
+@ stub DeleteApplicabilityInfoArray
+@ stub UpdateAgentCreateDownload
+@ stub UpdateAgentGetDownloadRanges
+@ stub UpdateAgentCancelAllDownloads
+@ stub UpdateDataSourceRegister
+@ stub UpdateDataSourceAddRange
+@ stub UpdateDataSourceRun
+@ stub UpdateDataSourceCancelRun
+@ stub GetPackageRegistrationStatusForUser
+@ stub IsSharedAppsEnabled
+@ stub AppInstallerUpdateAllTask
+@ stub CheckAppInstallerUpdateAvailability
+@ stub UpdateAgentFreeDownloadRanges
+@ stub AppxRegisterPackage
+@ stub IsPackageMetadataUnderSystemMetadata
+@ stub GetMetadataRootForPackage
+@ stub ClientGetAllPackagesToBeInstalledForUser
+@ stub ClientDeleteAllPackagesFromMainPackageArray
+@ stub GetPackageRegistrationStatusForUserAndDefaultAccount
+@ stub UpdateAgentGetDownloadingPackageCount
+@ stub PreRegisterPackagesInContainer
+@ stub EnsurePackageFamiliesAreRegisteredInContainer
+@ stub RemovePackageFromContainer
+@ stub HasPackageFamilyBeenRegisteredForUser
+@ stub CleanupProfileForUser
+@ stub AppxRemoveAllPackagesForUserSid
+@ stub AppxCreateSharedLocalFolderForFamilyName
+@ stub AppxDoesSharedLocalFolderExistForFamilyName
+@ stub AppxValidatePackages
+@ stub CheckForUpdatesAndWaitForInstallerIfNeeded
+@ stdcall -private DllCanUnloadNow()
+@ stdcall -private DllGetActivationFactory(ptr ptr)
+@ stdcall -private DllGetClassObject(ptr ptr ptr)
--- a/dlls/appxdeploymentclient/classes.idl
+++ b/dlls/appxdeploymentclient/classes.idl
@ -0,0 +1,23 @@
+/*
+ * Runtime Classes for appxdeploymentclient.dll
+ *
+ * Copyright (C) 2023 Mohamad Al-Jaf
+ *
+ * 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
+ */
+
+#pragma makedep register
+
+#include "windows.management.deployment.idl"
--- a/dlls/appxdeploymentclient/main.c
+++ b/dlls/appxdeploymentclient/main.c
@ -0,0 +1,46 @@
+/* WinRT Windows.Management.Deployment Implementation
+ *
+ * Copyright (C) 2023 Mohamad Al-Jaf
+ *
+ * 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 "initguid.h"
+#include "private.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(appx);
+
+HRESULT WINAPI DllGetClassObject( REFCLSID clsid, REFIID riid, void **out )
+{
+    FIXME( "clsid %s, riid %s, out %p stub!\n", debugstr_guid(clsid), debugstr_guid(riid), out );
+    return CLASS_E_CLASSNOTAVAILABLE;
+}
+
+HRESULT WINAPI DllGetActivationFactory( HSTRING classid, IActivationFactory **factory )
+{
+    const WCHAR *buffer = WindowsGetStringRawBuffer( classid, NULL );
+
+    TRACE( "class %s, factory %p.\n", debugstr_hstring(classid), factory );
+
+    *factory = NULL;
+
+    if (!wcscmp( buffer, RuntimeClass_Windows_Management_Deployment_PackageManager ))
+        IActivationFactory_QueryInterface( package_manager_factory, &IID_IActivationFactory, (void **)factory );
+
+    if (*factory) return S_OK;
+    return CLASS_E_CLASSNOTAVAILABLE;
+}
--- a/dlls/appxdeploymentclient/package.c
+++ b/dlls/appxdeploymentclient/package.c
@ -0,0 +1,434 @@
+/* WinRT Windows.Management.Deployment.PackageManager Implementation
+ *
+ * Copyright (C) 2023 Mohamad Al-Jaf
+ *
+ * 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 "private.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(appx);
+
+struct package_manager
+{
+    IPackageManager IPackageManager_iface;
+    IPackageManager2 IPackageManager2_iface;
+    LONG ref;
+};
+
+static inline struct package_manager *impl_from_IPackageManager( IPackageManager *iface )
+{
+    return CONTAINING_RECORD( iface, struct package_manager, IPackageManager_iface );
+}
+
+static HRESULT WINAPI package_manager_QueryInterface( IPackageManager *iface, REFIID iid, void **out )
+{
+    struct package_manager *impl = impl_from_IPackageManager( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IPackageManager ))
+    {
+        *out = &impl->IPackageManager_iface;
+        IInspectable_AddRef( *out );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, &IID_IPackageManager2 ))
+    {
+        *out = &impl->IPackageManager2_iface;
+        IInspectable_AddRef( *out );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI package_manager_AddRef( IPackageManager *iface )
+{
+    struct package_manager *impl = impl_from_IPackageManager( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI package_manager_Release( IPackageManager *iface )
+{
+    struct package_manager *impl = impl_from_IPackageManager( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref) free( impl );
+    return ref;
+}
+
+static HRESULT WINAPI package_manager_GetIids( IPackageManager *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_GetRuntimeClassName( IPackageManager *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_GetTrustLevel( IPackageManager *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_AddPackageAsync( IPackageManager *iface, IUriRuntimeClass *uri,
+    IIterable_Uri *dependencies, DeploymentOptions options, IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, uri %p, dependencies %p, options %d, operation %p stub!\n", iface, uri, dependencies, options, operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_UpdatePackageAsync( IPackageManager *iface, IUriRuntimeClass *uri, IIterable_Uri *dependencies,
+    DeploymentOptions options, IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, uri %p, dependencies %p, options %d, operation %p stub!\n", iface, uri, dependencies, options, operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_RemovePackageAsync( IPackageManager *iface, HSTRING name,
+    IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, name %s, operation %p stub!\n", iface, debugstr_hstring(name), operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_StagePackageAsync( IPackageManager *iface, IUriRuntimeClass *uri, IIterable_Uri *dependencies,
+    IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, uri %p, dependencies %p, operation %p stub!\n", iface, uri, dependencies, operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_RegisterPackageAsync( IPackageManager *iface, IUriRuntimeClass *uri, IIterable_Uri *dependencies,
+    DeploymentOptions options, IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, uri %p, dependencies %p, options %d, operation %p stub!\n", iface, uri, dependencies, options, operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackages( IPackageManager *iface, IIterable_Package **packages )
+{
+    FIXME( "iface %p, packages %p stub!\n", iface, packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackagesByUserSecurityId( IPackageManager *iface, HSTRING sid, IIterable_Package **packages )
+{
+    FIXME( "iface %p, sid %s, packages %p stub!\n", iface, debugstr_hstring(sid), packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackagesByNamePublisher( IPackageManager *iface, HSTRING name, HSTRING publisher, IIterable_Package **packages )
+{
+    FIXME( "iface %p, name %s, publisher %s, packages %p stub!\n", iface, debugstr_hstring(name), debugstr_hstring(publisher), packages );
+
+    if (!name || !publisher) return E_INVALIDARG;
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackagesByUserSecurityIdNamePublisher( IPackageManager *iface, HSTRING sid,
+    HSTRING name, HSTRING publisher, IIterable_Package **packages )
+{
+    FIXME( "iface %p, sid %s, name %s, publisher %s, packages %p stub!\n", iface, debugstr_hstring(sid), debugstr_hstring(name), debugstr_hstring(publisher), packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindUsers( IPackageManager *iface, HSTRING name, IIterable_PackageUserInformation **users )
+{
+    FIXME( "iface %p, name %s, users %p stub!\n", iface, debugstr_hstring(name), users );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_SetPackageState( IPackageManager *iface, HSTRING name, PackageState state )
+{
+    FIXME("iface %p, name %s, state %d stub!\n", iface, debugstr_hstring(name), state);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackageByPackageFullName( IPackageManager *iface, HSTRING name, IPackage **package )
+{
+    FIXME( "iface %p, name %s, package %p stub!\n", iface, debugstr_hstring(name), package );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_CleanupPackageForUserAsync( IPackageManager *iface, HSTRING name, HSTRING sid,
+    IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, name %s, sid %s, operation %p stub!\n", iface, debugstr_hstring(name), debugstr_hstring(sid), operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackagesByPackageFamilyName( IPackageManager *iface, HSTRING family_name,
+    IIterable_Package **packages )
+{
+    FIXME( "iface %p, family_name %s, packages %p stub!\n", iface, debugstr_hstring(family_name), packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackagesByUserSecurityIdPackageFamilyName( IPackageManager *iface, HSTRING sid,
+    HSTRING family_name, IIterable_Package **packages )
+{
+    FIXME( "iface %p, sid %s, family_name %s, packages %p stub!\n", iface, debugstr_hstring(sid), debugstr_hstring(family_name), packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager_FindPackageByUserSecurityIdPackageFullName( IPackageManager *iface, HSTRING sid, HSTRING name, IPackage **package )
+{
+    FIXME( "iface %p, sid %s, name %s, package %p stub!\n", iface, debugstr_hstring(sid), debugstr_hstring(name), package );
+    return E_NOTIMPL;
+}
+
+static const struct IPackageManagerVtbl package_manager_vtbl =
+{
+    package_manager_QueryInterface,
+    package_manager_AddRef,
+    package_manager_Release,
+    /* IInspectable methods */
+    package_manager_GetIids,
+    package_manager_GetRuntimeClassName,
+    package_manager_GetTrustLevel,
+    /* IPackageManager methods */
+    package_manager_AddPackageAsync,
+    package_manager_UpdatePackageAsync,
+    package_manager_RemovePackageAsync,
+    package_manager_StagePackageAsync,
+    package_manager_RegisterPackageAsync,
+    package_manager_FindPackages,
+    package_manager_FindPackagesByUserSecurityId,
+    package_manager_FindPackagesByNamePublisher,
+    package_manager_FindPackagesByUserSecurityIdNamePublisher,
+    package_manager_FindUsers,
+    package_manager_SetPackageState,
+    package_manager_FindPackageByPackageFullName,
+    package_manager_CleanupPackageForUserAsync,
+    package_manager_FindPackagesByPackageFamilyName,
+    package_manager_FindPackagesByUserSecurityIdPackageFamilyName,
+    package_manager_FindPackageByUserSecurityIdPackageFullName
+};
+
+DEFINE_IINSPECTABLE( package_manager2, IPackageManager2, struct package_manager, IPackageManager_iface );
+
+static HRESULT WINAPI package_manager2_RemovePackageWithOptionsAsync( IPackageManager2 *iface, HSTRING name, RemovalOptions options,
+    IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, name %s, options %d, operation %p stub!\n", iface, debugstr_hstring(name), options, operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_StagePackageWithOptionsAsync( IPackageManager2 *iface, IUriRuntimeClass *uri, IIterable_Uri *dependencies,
+    DeploymentOptions options, IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, uri %p, dependencies %p, options %d, operation %p stub!\n", iface, uri, dependencies, options, operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_RegisterPackageByFullNameAsync( IPackageManager2 *iface, HSTRING name, IIterable_HSTRING *dependencies,
+    DeploymentOptions options, IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, name %s, dependencies %p, options %d, operation %p stub!\n", iface, debugstr_hstring(name), dependencies, options, operation );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_FindPackagesWithPackageTypes( IPackageManager2 *iface, PackageTypes types, IIterable_Package **packages )
+{
+    FIXME( "iface %p, types %d, packages %p stub!\n", iface, types, packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_FindPackagesByUserSecurityIdWithPackageTypes( IPackageManager2 *iface, HSTRING sid,
+    PackageTypes types, IIterable_Package **packages )
+{
+    FIXME( "iface %p, sid %s, types %d, packages %p stub!\n", iface, debugstr_hstring(sid), types, packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_FindPackagesByNamePublisherWithPackageTypes( IPackageManager2 *iface, HSTRING name, HSTRING publisher,
+    PackageTypes types, IIterable_Package **packages )
+{
+    FIXME( "iface %p, name %s, publisher %s, types %d, packages %p stub!\n", iface, debugstr_hstring(name), debugstr_hstring(publisher), types, packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_FindPackagesByUserSecurityIdNamePublisherWithPackageTypes( IPackageManager2 *iface, HSTRING sid, HSTRING name,
+    HSTRING publisher, PackageTypes types, IIterable_Package **packages )
+{
+    FIXME( "iface %p, sid %s, name %s, publisher %s, types %d, packages %p stub!\n", iface, debugstr_hstring(sid), debugstr_hstring(name), debugstr_hstring(publisher), types, packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_FindPackagesByPackageFamilyNameWithPackageTypes( IPackageManager2 *iface, HSTRING family_name, PackageTypes types,
+   IIterable_Package **packages )
+{
+    FIXME( "iface %p, family_name %s, types %d, packages %p stub!\n", iface, debugstr_hstring(family_name), types, packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_FindPackagesByUserSecurityIdPackageFamilyNameWithPackageTypes( IPackageManager2 *iface, HSTRING sid, HSTRING family_name,
+    PackageTypes types, IIterable_Package **packages )
+{
+    FIXME( "iface %p, sid %s, family_name %s, types %d, packages %p stub!\n", iface, debugstr_hstring(sid), debugstr_hstring(family_name), types, packages );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI package_manager2_StageUserDataAsync( IPackageManager2 *iface, HSTRING name,
+    IAsyncOperationWithProgress_DeploymentResult_DeploymentProgress **operation )
+{
+    FIXME( "iface %p, name %s, operation %p stub!\n", iface, debugstr_hstring(name), operation );
+    return E_NOTIMPL;
+}
+
+static const struct IPackageManager2Vtbl package_manager2_vtbl =
+{
+    package_manager2_QueryInterface,
+    package_manager2_AddRef,
+    package_manager2_Release,
+    /* IInspectable methods */
+    package_manager2_GetIids,
+    package_manager2_GetRuntimeClassName,
+    package_manager2_GetTrustLevel,
+    /* IPackageManager2 methods */
+    package_manager2_RemovePackageWithOptionsAsync,
+    package_manager2_StagePackageWithOptionsAsync,
+    package_manager2_RegisterPackageByFullNameAsync,
+    package_manager2_FindPackagesWithPackageTypes,
+    package_manager2_FindPackagesByUserSecurityIdWithPackageTypes,
+    package_manager2_FindPackagesByNamePublisherWithPackageTypes,
+    package_manager2_FindPackagesByUserSecurityIdNamePublisherWithPackageTypes,
+    package_manager2_FindPackagesByPackageFamilyNameWithPackageTypes,
+    package_manager2_FindPackagesByUserSecurityIdPackageFamilyNameWithPackageTypes,
+    package_manager2_StageUserDataAsync,
+};
+
+struct package_manager_statics
+{
+    IActivationFactory IActivationFactory_iface;
+    LONG ref;
+};
+
+static inline struct package_manager_statics *impl_from_IActivationFactory( IActivationFactory *iface )
+{
+    return CONTAINING_RECORD( iface, struct package_manager_statics, IActivationFactory_iface );
+}
+
+static HRESULT WINAPI factory_QueryInterface( IActivationFactory *iface, REFIID iid, void **out )
+{
+    struct package_manager_statics *impl = impl_from_IActivationFactory( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IActivationFactory ))
+    {
+        *out = &impl->IActivationFactory_iface;
+        IInspectable_AddRef( *out );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI factory_AddRef( IActivationFactory *iface )
+{
+    struct package_manager_statics *impl = impl_from_IActivationFactory( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI factory_Release( IActivationFactory *iface )
+{
+    struct package_manager_statics *impl = impl_from_IActivationFactory( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static HRESULT WINAPI factory_GetIids( IActivationFactory *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI factory_GetRuntimeClassName( IActivationFactory *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI factory_GetTrustLevel( IActivationFactory *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI factory_ActivateInstance( IActivationFactory *iface, IInspectable **instance )
+{
+    struct package_manager *impl;
+
+    TRACE( "iface %p, instance %p.\n", iface, instance );
+
+    if (!(impl = calloc( 1, sizeof(*impl) )))
+    {
+        *instance = NULL;
+        return E_OUTOFMEMORY;
+    }
+
+    impl->IPackageManager_iface.lpVtbl = &package_manager_vtbl;
+    impl->IPackageManager2_iface.lpVtbl = &package_manager2_vtbl;
+    impl->ref = 1;
+
+    *instance = (IInspectable *)&impl->IPackageManager_iface;
+    return S_OK;
+}
+
+static const struct IActivationFactoryVtbl factory_vtbl =
+{
+    factory_QueryInterface,
+    factory_AddRef,
+    factory_Release,
+    /* IInspectable methods */
+    factory_GetIids,
+    factory_GetRuntimeClassName,
+    factory_GetTrustLevel,
+    /* IActivationFactory methods */
+    factory_ActivateInstance,
+};
+
+static struct package_manager_statics package_manager_statics =
+{
+    {&factory_vtbl},
+    1,
+};
+
+IActivationFactory *package_manager_factory = &package_manager_statics.IActivationFactory_iface;
--- a/dlls/appxdeploymentclient/private.h
+++ b/dlls/appxdeploymentclient/private.h
@ -0,0 +1,79 @@
+/* WinRT Windows.Management.Deployment Implementation
+ *
+ * Copyright (C) 2023 Mohamad Al-Jaf
+ *
+ * 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
+ */
+
+#ifndef __WINE_WINDOWS_MANAGEMENT_DEPLOYMENT_PRIVATE_H
+#define __WINE_WINDOWS_MANAGEMENT_DEPLOYMENT_PRIVATE_H
+
+#include <stdarg.h>
+
+#define COBJMACROS
+#include "windef.h"
+#include "winbase.h"
+#include "winstring.h"
+
+#include "activation.h"
+
+#define WIDL_using_Windows_Foundation
+#define WIDL_using_Windows_Foundation_Collections
+#include "windows.foundation.h"
+#define WIDL_using_Windows_Management_Deployment
+#define WIDL_using_Windows_ApplicationModel
+#include "windows.management.deployment.h"
+
+extern IActivationFactory *package_manager_factory;
+
+#define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
+    static inline impl_type *impl_from( iface_type *iface )                                        \
+    {                                                                                              \
+        return CONTAINING_RECORD( iface, impl_type, iface_mem );                                   \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_QueryInterface( iface_type *iface, REFIID iid, void **out )        \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_QueryInterface( (IInspectable *)(expr), iid, out );                    \
+    }                                                                                              \
+    static ULONG WINAPI pfx##_AddRef( iface_type *iface )                                          \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_AddRef( (IInspectable *)(expr) );                                      \
+    }                                                                                              \
+    static ULONG WINAPI pfx##_Release( iface_type *iface )                                         \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_Release( (IInspectable *)(expr) );                                     \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_GetIids( iface_type *iface, ULONG *iid_count, IID **iids )         \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_GetIids( (IInspectable *)(expr), iid_count, iids );                    \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_GetRuntimeClassName( iface_type *iface, HSTRING *class_name )      \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_GetRuntimeClassName( (IInspectable *)(expr), class_name );             \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_GetTrustLevel( iface_type *iface, TrustLevel *trust_level )        \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_GetTrustLevel( (IInspectable *)(expr), trust_level );                  \
+    }
+#define DEFINE_IINSPECTABLE( pfx, iface_type, impl_type, base_iface )                              \
+    DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from_##iface_type, iface_type##_iface, &impl->base_iface )
+
+#endif
--- a/dlls/atl/Makefile.in
+++ b/dlls/atl/Makefile.in
@ -3,12 +3,10 @@ IMPORTLIB = atl
 IMPORTS   = uuid oleaut32 ole32 user32 gdi32 advapi32 shlwapi
 EXTRADEFS = -D_ATL_VER=_ATL_VER_30

-C_SRCS = \
+SOURCES = \
 	atl.c \
 	atl30.c \
 	atl_ax.c \
-	registrar.c
-
-IDL_SRCS = \
 	atl_classes.idl \
-	atl_lib.idl
+	atl_lib.idl \
+	registrar.c
--- a/dlls/atl/registrar.c
+++ b/dlls/atl/registrar.c
@ -280,7 +280,7 @@ static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOO
                    hres = get_word(&iter, buf);
                    if(FAILED(hres))
                        break;
-                    dw = wcstol(buf->str, NULL, 10);
+                    dw = wcstoul(buf->str, NULL, 10);
                    lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_DWORD,
                            (PBYTE)&dw, sizeof(dw));
                    if(lres != ERROR_SUCCESS) {
--- a/dlls/atl/tests/Makefile.in
+++ b/dlls/atl/tests/Makefile.in
@ -2,7 +2,7 @@ TESTDLL   = atl.dll
 IMPORTS   = uuid atl oleaut32 ole32 rpcrt4 user32 gdi32 advapi32
 EXTRADEFS = -D_ATL_VER=_ATL_VER_30

-C_SRCS = \
+SOURCES = \
 	atl_ax.c \
 	module.c \
 	registrar.c
--- a/dlls/atl/tests/registrar.c
+++ b/dlls/atl/tests/registrar.c
@ -49,6 +49,10 @@ static const char textA[] =
 "        val 'dword_unquoted_dec' = d 1 \n"
 "        val 'dword_quoted_hex' = d '0xA' \n"
 "        val 'dword_unquoted_hex' = d 0xA \n"
+"        val 'dword_negative' = d -2147483648 \n"
+"        val 'dword_ulong' = d 2147483649 \n"
+"        val 'dword_max' = d 4294967295 \n"
+"        val 'dword_overrange' = d 4294967296 \n"
 "        val 'binary_quoted' = b 'deadbeef' \n"
 "        val 'binary_unquoted' = b dead0123 \n"
 "    } \n"
@ -59,7 +63,24 @@ static void test_registrar(void)
    IRegistrar *registrar = NULL;
    HRESULT hr;
    INT count;
+    int i;
    WCHAR *textW = NULL;
+    struct dword_test
+    {
+        const char *name;
+        BOOL preserved;
+        LONGLONG value;
+    } dword_tests[] =
+    {
+        { "dword_unquoted_dec", TRUE,  1 },
+        { "dword_quoted_dec",   TRUE,  1 },
+        { "dword_quoted_hex",   FALSE, 0xA },
+        { "dword_unquoted_hex", FALSE, 0xA },
+        { "dword_negative",     FALSE, -2147483648 },
+        { "dword_ulong",        TRUE,  2147483649 },
+        { "dword_max",          TRUE,  4294967295 },
+        { "dword_overrange",    FALSE, 4294967296 },
+    };

    if (!GetProcAddress(GetModuleHandleA("atl.dll"), "AtlAxAttachControl"))
    {
@ -112,25 +133,16 @@ static void test_registrar(void)
        ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %ld\n", lret);
        ok(!strcmp( buffer, "str'ing"), "wrong data %s\n", debugstr_a(buffer));

-        size = sizeof(dword);
-        lret = RegQueryValueExA(key, "dword_unquoted_hex", NULL, NULL, (BYTE*)&dword, &size);
-        ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %ld\n", lret);
-        ok(dword != 0xA, "unquoted hex is not supposed to be preserved\n");
-
-        size = sizeof(dword);
-        lret = RegQueryValueExA(key, "dword_quoted_hex", NULL, NULL, (BYTE*)&dword, &size);
-        ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %ld\n", lret);
-        ok(dword != 0xA, "quoted hex is not supposed to be preserved\n");
-
-        size = sizeof(dword);
-        lret = RegQueryValueExA(key, "dword_unquoted_dec", NULL, NULL, (BYTE*)&dword, &size);
-        ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %ld\n", lret);
-        ok(dword == 1, "unquoted dec is not supposed to be %ld\n", dword);
-
-        size = sizeof(dword);
-        lret = RegQueryValueExA(key, "dword_quoted_dec", NULL, NULL, (BYTE*)&dword, &size);
-        ok(lret == ERROR_SUCCESS, "RegQueryValueExA failed, error %ld\n", lret);
-        ok(dword == 1, "quoted dec is not supposed to be %ld\n", dword);
+        for (i = 0; i < ARRAYSIZE(dword_tests); i++)
+        {
+            size = sizeof(dword);
+            lret = RegQueryValueExA(key, dword_tests[i].name, NULL, NULL, (BYTE*)&dword, &size);
+            ok(lret == ERROR_SUCCESS, "Test %d: RegQueryValueExA failed %ld.\n", i, lret);
+            if (dword_tests[i].preserved)
+                ok(dword == dword_tests[i].value, "Test %d: got unexpected value %lu.\n", i, dword);
+            else
+                ok(dword != dword_tests[i].value, "Test %d: is not supposed to be preserved.\n", i);
+        }

        size = 4;
        lret = RegQueryValueExA(key, "binary_quoted", NULL, NULL, bytes, &size);
--- a/dlls/atl100/Makefile.in
+++ b/dlls/atl100/Makefile.in
@ -4,9 +4,8 @@ IMPORTS   = uuid ole32 oleaut32 user32 gdi32 advapi32 shlwapi
 EXTRADEFS = -D_ATL_VER=_ATL_VER_100
 PARENTSRC = ../atl

-C_SRCS = \
+SOURCES = \
 	atl.c \
 	atl_ax.c \
+	atl_lib.idl \
 	registrar.c
-
-IDL_SRCS = atl_lib.idl
--- a/dlls/atl100/tests/Makefile.in
+++ b/dlls/atl100/tests/Makefile.in
@ -2,5 +2,5 @@ TESTDLL   = atl100.dll
 IMPORTS   = uuid atl100 oleaut32 ole32 advapi32 user32
 EXTRADEFS = -D_ATL_VER=_ATL_VER_100

-C_SRCS = \
+SOURCES = \
 	atl.c
--- a/dlls/atl110/Makefile.in
+++ b/dlls/atl110/Makefile.in
@ -4,9 +4,8 @@ IMPORTS   = oleaut32 ole32 user32 gdi32 advapi32 uuid shlwapi
 EXTRADEFS = -D_ATL_VER=_ATL_VER_110
 PARENTSRC = ../atl

-C_SRCS = \
+SOURCES = \
 	atl.c \
 	atl_ax.c \
+	atl_lib.idl \
 	registrar.c
-
-IDL_SRCS = atl_lib.idl
--- a/dlls/atl110/tests/Makefile.in
+++ b/dlls/atl110/tests/Makefile.in
@ -2,5 +2,5 @@ TESTDLL   = atl110.dll
 IMPORTS   = uuid ole32 atl110
 EXTRADEFS = -D_ATL_VER=_ATL_VER_110

-C_SRCS = \
+SOURCES = \
 	atl.c
--- a/dlls/atl80/Makefile.in
+++ b/dlls/atl80/Makefile.in
@ -4,12 +4,10 @@ IMPORTS   = oleaut32 user32 ole32 gdi32 advapi32 uuid shlwapi
 EXTRADEFS = -D_ATL_VER=_ATL_VER_80
 PARENTSRC = ../atl

-C_SRCS = \
+SOURCES = \
 	atl.c \
 	atl80.c \
+	atl80.rc \
 	atl_ax.c \
+	atl_lib.idl \
 	registrar.c
-
-IDL_SRCS = atl_lib.idl
-
-RC_SRCS = atl80.rc
--- a/dlls/atl80/tests/Makefile.in
+++ b/dlls/atl80/tests/Makefile.in
@ -2,8 +2,6 @@ TESTDLL   = atl80.dll
 IMPORTS   = uuid atl80 oleaut32 ole32 advapi32 user32
 EXTRADEFS = -D_ATL_VER=_ATL_VER_80

-C_SRCS = \
-	atl.c
-
-RC_SRCS = \
+SOURCES = \
+	atl.c \
 	atl80.rc
--- a/dlls/atl90/Makefile.in
+++ b/dlls/atl90/Makefile.in
@ -3,11 +3,9 @@ IMPORTS   = oleaut32 user32 ole32 gdi32 advapi32 uuid shlwapi
 EXTRADEFS = -D_ATL_VER=_ATL_VER_90
 PARENTSRC = ../atl

-C_SRCS = \
+SOURCES = \
 	atl.c \
+	atl90.rc \
 	atl_ax.c \
+	atl_lib.idl \
 	registrar.c
-
-IDL_SRCS = atl_lib.idl
-
-RC_SRCS = atl90.rc
--- a/dlls/atlthunk/Makefile.in
+++ b/dlls/atlthunk/Makefile.in
@ -1,5 +1,5 @@
 MODULE    = atlthunk.dll
 IMPORTLIB = atlthunk

-C_SRCS = \
+SOURCES = \
 	atlthunk.c
--- a/dlls/atlthunk/tests/Makefile.in
+++ b/dlls/atlthunk/tests/Makefile.in
@ -1,6 +1,5 @@
 TESTDLL   = atlthunk.dll
 IMPORTS   = atlthunk

-
-C_SRCS = \
+SOURCES = \
 	atlthunk.c
--- a/dlls/atmlib/Makefile.in
+++ b/dlls/atmlib/Makefile.in
@ -2,5 +2,5 @@ MODULE    = atmlib.dll

 EXTRADLLFLAGS = -Wb,--prefer-native

-C_SRCS = \
+SOURCES = \
 	main.c
--- a/Show more
+++ b/Show more