wine-devel January 2022

86 participants
717 discussions

[PATCH 1/2] qedit/tests: Check the Sample Grabber's buffer during and after flushing.

by Gabriel Ivăncescu

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/qedit/tests/samplegrabber.c | 234 +++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) diff --git a/dlls/qedit/tests/samplegrabber.c b/dlls/qedit/tests/samplegrabber.c index 8e68e3e..e66180f 100644 --- a/dlls/qedit/tests/samplegrabber.c +++ b/dlls/qedit/tests/samplegrabber.c @@ -1036,6 +1036,239 @@ static void test_connect_pin(void) ok(!ref, "Got outstanding refcount %d.\n", ref); } +struct frame_thread_params +{ + IMemInputPin *sink; + IMediaSample *sample; + DWORD delay; +}; + +static DWORD WINAPI frame_thread(void *arg) +{ + struct frame_thread_params *params = arg; + HRESULT hr; + + if (params->delay) + { + if (winetest_debug > 1) trace("%04x: Sleeping %u ms.\n", GetCurrentThreadId(), params->delay); + Sleep(params->delay); + } + if (winetest_debug > 1) trace("%04x: Sending frame.\n", GetCurrentThreadId()); + hr = IMemInputPin_Receive(params->sink, params->sample); + if (winetest_debug > 1) trace("%04x: Returned %#x.\n", GetCurrentThreadId(), hr); + IMediaSample_Release(params->sample); + free(params); + return hr; +} + +static HANDLE send_frame_time(IMemInputPin *sink, REFERENCE_TIME start_time, unsigned char color, DWORD delay) +{ + struct frame_thread_params *params = malloc(sizeof(*params)); + IMemAllocator *allocator; + REFERENCE_TIME end_time; + IMediaSample *sample; + HANDLE thread; + HRESULT hr; + BYTE *data; + + hr = IMemInputPin_GetAllocator(sink, &allocator); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + if (hr == VFW_E_NOT_COMMITTED) + { + IMemAllocator_Commit(allocator); + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + } + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSample_GetPointer(sample, &data); + ok(hr == S_OK, "Got hr %#x.\n", hr); + memset(data, 0x55, 32 * 16 * 2); + + hr = IMediaSample_SetActualDataLength(sample, 32 * 16 * 2); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + start_time *= 10000000; + end_time = start_time + 10000000; + hr = IMediaSample_SetTime(sample, &start_time, &end_time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + params->sink = sink; + params->sample = sample; + params->delay = delay; + thread = CreateThread(NULL, 0, frame_thread, params, 0, NULL); + + IMemAllocator_Release(allocator); + return thread; +} + +static HANDLE send_frame(IMemInputPin *sink, DWORD delay) +{ + return send_frame_time(sink, 0, 0x55, delay); /* purple */ +} + +static HRESULT join_thread_(int line, HANDLE thread) +{ + DWORD ret; + ok_(__FILE__, line)(!WaitForSingleObject(thread, 1000), "Wait failed.\n"); + GetExitCodeThread(thread, &ret); + CloseHandle(thread); + return ret; +} +#define join_thread(a) join_thread_(__LINE__, a) + +static void test_buffer_flush(void) +{ + AM_MEDIA_TYPE req_mt = + { + .majortype = MEDIATYPE_Video, + .subtype = MEDIASUBTYPE_RGB565, + .formattype = FORMAT_VideoInfo, + .bTemporalCompression = TRUE, + }; + LONG buf[(32 * 16 * 2) / sizeof(LONG)], size = sizeof(buf); + IPin *sink, *source, *renderer_pin; + struct testfilter testsource; + ISampleGrabber *grabber; + IMediaControl *control; + IFilterGraph2 *graph; + IMemInputPin *input; + IBaseFilter *filter; + OAFilterState state; + IMediaFilter *mf; + HANDLE thread; + DWORD ticks; + unsigned i; + HRESULT hr; + ULONG ref; + + testfilter_init(&testsource); + CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, + &IID_IFilterGraph2, (void **)&graph); + CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter); + IFilterGraph2_AddFilter(graph, filter, L"sink"); + IBaseFilter_FindPin(filter, L"In", &renderer_pin); + IBaseFilter_Release(filter); + + filter = create_sample_grabber(); + IFilterGraph2_AddFilter(graph, &testsource.filter.IBaseFilter_iface, L"source"); + IFilterGraph2_AddFilter(graph, filter, L"sample grabber"); + IBaseFilter_FindPin(filter, L"In", &sink); + IBaseFilter_FindPin(filter, L"Out", &source); + IBaseFilter_QueryInterface(filter, &IID_ISampleGrabber, (void **)&grabber); + IFilterGraph2_QueryInterface(graph, &IID_IMediaControl, (void **)&control); + IPin_QueryInterface(sink, &IID_IMemInputPin, (void **)&input); + + ISampleGrabber_SetMediaType(grabber, &req_mt); + ISampleGrabber_SetBufferSamples(grabber, TRUE); + + testsource.sink_mt = &req_mt; + hr = IFilterGraph2_ConnectDirect(graph, &testsource.source.pin.IPin_iface, sink, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IFilterGraph2_ConnectDirect(graph, source, renderer_pin, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_Release(renderer_pin); + + IFilterGraph2_QueryInterface(graph, &IID_IMediaFilter, (void **)&mf); + IMediaFilter_SetSyncSource(mf, NULL); + IMediaFilter_Release(mf); + + hr = IMemInputPin_ReceiveCanBlock(input); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == VFW_E_WRONG_STATE, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Stopped, "Got state %d.\n", state); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + IPin_BeginFlush(sink); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_EndFlush(sink); + + hr = IMediaControl_GetState(control, 0, &state); + todo_wine ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + ticks = GetTickCount(); + thread = send_frame(input, 150); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + IPin_Release(sink); + IPin_Release(source); + IMemInputPin_Release(input); + IMediaControl_Release(control); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ISampleGrabber_Release(grabber); + ref = IBaseFilter_Release(filter); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ref = IBaseFilter_Release(&testsource.filter.IBaseFilter_iface); + ok(!ref, "Got outstanding refcount %d.\n", ref); +} + START_TEST(samplegrabber) { IBaseFilter *filter; @@ -1059,6 +1292,7 @@ START_TEST(samplegrabber) test_aggregation(); test_media_types(); test_connect_pin(); + test_buffer_flush(); CoUninitialize(); } -- 2.21.0

1 year, 6 months

[PATCH 1/2] shell32: Only call HCR_GetFolderAttributes with simple pidls

by Fabian Maurer

The function returns false with not-simple pidls anyways. This fixes an "ERR" message when opening a control panel applet from explorer Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/shell32/shlfolder.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/shell32/shlfolder.c b/dlls/shell32/shlfolder.c index 10aafc160c0..8e3b561cfd1 100644 --- a/dlls/shell32/shlfolder.c +++ b/dlls/shell32/shlfolder.c @@ -412,7 +412,7 @@ HRESULT SHELL32_GetItemAttributes (IShellFolder2 *psf, LPCITEMIDLIST pidl, LPDWO if (_ILIsDrive (pidl)) { *pdwAttributes &= SFGAO_HASSUBFOLDER|SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_FILESYSANCESTOR| SFGAO_DROPTARGET|SFGAO_HASPROPSHEET|SFGAO_CANLINK; - } else if (has_guid && HCR_GetFolderAttributes(pidl, &dwAttributes)) { + } else if (has_guid && _ILIsPidlSimple(pidl) && HCR_GetFolderAttributes(pidl, &dwAttributes)) { *pdwAttributes = dwAttributes; } else if (_ILGetDataPointer (pidl)) { DWORD file_attr = _ILGetFileAttributes (pidl, NULL, 0); -- 2.34.1

1 year, 12 months

[PATCH 1/4] riched20: draw OLE object in richedit with OleDraw

by Dongwan Kim

When OLE object provides IViewObject::Draw, Richedit can draw it even though the OLE object does not support CF_BITMAP nor CF_ENHMETAFILE. Signed-off-by: Dongwan Kim <kdw6485(a)gmail.com> --- dlls/riched20/richole.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/dlls/riched20/richole.c b/dlls/riched20/richole.c index 03572511ff7..1a62f0b9f36 100644 --- a/dlls/riched20/richole.c +++ b/dlls/riched20/richole.c @@ -5653,6 +5653,7 @@ void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize) STGMEDIUM stgm; DIBSECTION dibsect; ENHMETAHEADER emh; + int pixs; assert(run->nFlags & MERF_GRAPHICS); assert(run->reobj); @@ -5691,8 +5692,13 @@ void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize) fmt.tymed = TYMED_ENHMF; if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK) { - FIXME("unsupported format\n"); - pSize->cx = pSize->cy = 0; + if( IOleObject_GetExtent(run->reobj->obj.poleobj, DVASPECT_CONTENT, pSize) != S_OK){ + FIXME("unsupported format\n"); + pSize->cx = pSize->cy = 0; + } + pixs = GetDeviceCaps(c->hDC, LOGPIXELSX); + pSize->cx = MulDiv(pSize->cx, pixs , 2540); + pSize->cy = MulDiv(pSize->cy, pixs , 2540); IDataObject_Release(ido); return; } @@ -5735,6 +5741,8 @@ void draw_ole( ME_Context *c, int x, int y, ME_Run *run, BOOL selected ) BOOL has_size; HBITMAP old_bm; RECT rc; + HRESULT hr; + int pixs; assert(run->nFlags & MERF_GRAPHICS); assert(run->reobj); @@ -5755,7 +5763,17 @@ void draw_ole( ME_Context *c, int x, int y, ME_Run *run, BOOL selected ) fmt.tymed = TYMED_ENHMF; if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK) { - FIXME("Couldn't get storage medium\n"); + IOleObject_GetExtent(run->reobj->obj.poleobj, DVASPECT_CONTENT, &sz); + pixs = GetDeviceCaps(c->hDC, LOGPIXELSX); + rc.left = x; + rc.top = y - MulDiv(sz.cy, pixs, 2540); + rc.right = x + MulDiv(sz.cx, pixs, 2540); + rc.bottom = y ; + hr = OleDraw(run->reobj->obj.poleobj, DVASPECT_CONTENT, c->hDC, &rc); + if (FAILED(hr)) + { + FIXME("Couldn't draw ole object\n"); + } IDataObject_Release(ido); return; } -- 2.30.2

2 years

[PATCH 1/2] api-ms-win-core-privateprofile-l1-1-0: Add dll.

by Mohamad Al-Jaf

Needed for native mfc42u.dll. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51850 Signed-off-by: Mohamad Al-Jaf <mohamadaljaf(a)gmail.com> --- The bug report does not mention that the tool cannot run without mfc42u.dll, which requires this API set. --- configure.ac | 1 + .../Makefile.in | 1 + .../api-ms-win-core-privateprofile-l1-1-0.spec | 14 ++++++++++++++ 3 files changed, 16 insertions(+) create mode 100644 dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in create mode 100644 dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec diff --git a/configure.ac b/configure.ac index 9b2c111119f..9630405bfcd 100644 --- a/configure.ac +++ b/configure.ac @@ -2416,6 +2416,7 @@ WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-namedpipe-l1-2-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-namespace-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-normalization-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-path-l1-1-0) +WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-privateprofile-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-privateprofile-l1-1-1) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-processenvironment-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-processenvironment-l1-2-0) diff --git a/dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in b/dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in new file mode 100644 index 00000000000..c8b8ef84aef --- /dev/null +++ b/dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in @@ -0,0 +1 @@ +MODULE = api-ms-win-core-privateprofile-l1-1-0.dll diff --git a/dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec b/dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec new file mode 100644 index 00000000000..c8153c3a296 --- /dev/null +++ b/dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec @@ -0,0 +1,14 @@ +@ stdcall GetPrivateProfileIntA(str str long str) kernel32.GetPrivateProfileIntA +@ stdcall GetPrivateProfileIntW(wstr wstr long wstr) kernel32.GetPrivateProfileIntW +@ stdcall GetPrivateProfileSectionW(wstr ptr long wstr) kernel32.GetPrivateProfileSectionW +@ stdcall GetPrivateProfileStringA(str str str ptr long str) kernel32.GetPrivateProfileStringA +@ stdcall GetPrivateProfileStringW(wstr wstr wstr ptr long wstr) kernel32.GetPrivateProfileStringW +@ stdcall GetProfileIntA(str str long) kernel32.GetProfileIntA +@ stdcall GetProfileIntW(wstr wstr long) kernel32.GetProfileIntW +@ stdcall GetProfileSectionA(str ptr long) kernel32.GetProfileSectionA +@ stdcall GetProfileSectionW(wstr ptr long) kernel32.GetProfileSectionW +@ stdcall GetProfileStringA(str str str ptr long) kernel32.GetProfileStringA +@ stdcall GetProfileStringW(wstr wstr wstr ptr long) kernel32.GetProfileStringW +@ stdcall WritePrivateProfileSectionA(str str str) kernel32.WritePrivateProfileSectionA +@ stdcall WritePrivateProfileStringA(str str str str) kernel32.WritePrivateProfileStringA +@ stdcall WritePrivateProfileStringW(wstr wstr wstr wstr) kernel32.WritePrivateProfileStringW -- 2.34.1

2 years

[PATCH v3 0/5] Implement reflink support

by Alex Xu (Hello71)

Over the years, Wine prefixes have gotten bigger and bigger, for a number of reasons. Creating a new Wine prefix for each application is still the current recommendation, as despite the best efforts of Wine developers, some applications still require system-wide workarounds. This leads to significant bloat for each application installed. With a MinGW build of Wine without Mono or Gecko, new 32-bit prefixes are over 150 MB, and new 64-bit prefixes are over 300 MB. The vast majority of these files are byte-for-byte identical to Wine's central DLL copies. This patch set implements reflink support in Wine via the copy_file_range syscall. The reasons for selecting copy_file_range over FICLONE are outlined in patch 2. A previous unpublished version of this patch set used FICLONERANGE, but it was less convenient to use from setupapi and has inferior system support. When reflink is supported by the underlying filesystem, new Wine prefix sizes with Mono and Gecko disabled are reduced to less than 1 MB. The resulting Wine prefix is byte-for-byte identical to one created without reflink, but occupies less space on disk. If hard links or symlinks were used, if an application such as winetricks writes to a system file, it would overwrite the central copy. With reflink, the file blocks will be transparently copied by the Linux kernel so that each Wine prefix can be independent. Some files cannot be deduplicated in the current Wine system, as they are dynamically generated during the Wine prefix installation process. These include 16-bit fake DLLs and manifest files. In theory, it should be possible to pre-generate these files, but considering the Wine prefix size is already reduced to less than 1 MB, the extra space savings are likely not worth the effort. v1->v2: Fix/improve errno handling. v2->v3: Rebase. Alex Xu (Hello71) (5): ntdll: add support for IOCTL_COPYCHUNK. kernelbase: use IOCTL_COPYCHUNK in CopyFile* setupapi: Use IOCTL_COPYCHUNK, avoid buffering whole file lmshare.h: define STYPE_TEMPORARY kernel32/tests: add IOCTL_COPYCHUNK test configure | 6 ++ configure.ac | 1 + dlls/kernel32/tests/file.c | 137 +++++++++++++++++++++++++ dlls/kernelbase/file.c | 44 ++++----- dlls/ntdll/unix/file.c | 121 +++++++++++++++++++++++ dlls/setupapi/fakedll.c | 198 ++++++++++++++++++++----------------- include/config.h.in | 3 + include/lmshare.h | 11 ++- include/winioctl.h | 34 +++++++ 9 files changed, 434 insertions(+), 121 deletions(-) -- 2.35.0

2 years, 2 months

[PATCH 1/2] user32: Test Get/SetWindowPlacement with invalid length.

by Esme Povirk

Signed-off-by: Esme Povirk <esme(a)codeweavers.com> --- dlls/user32/tests/win.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index cb6b61e59c0..b1ef97c01d6 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -12086,6 +12086,17 @@ static void test_window_placement(void) GetWindowRect(hwnd, &rect); ok(EqualRect(&rect, &orig), "got window rect %s\n", wine_dbgstr_rect(&rect)); + ret = SetWindowPlacement(hwnd, &wp); + ok(ret, "failed to set window placement, error %u\n", GetLastError()); + + wp.length = 0; + SetLastError(0xdeadbeef); + ret = SetWindowPlacement(hwnd, &wp); +todo_wine { + ok(!ret, "SetWindowPlacement should have failed\n"); + ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError()); +} + DestroyWindow(hwnd); } @@ -12245,7 +12256,7 @@ static void test_arrange_iconic_windows(void) static void other_process_proc(HWND hwnd) { HANDLE window_ready_event, test_done_event; - WINDOWPLACEMENT wp; + WINDOWPLACEMENT wp = {0}; DWORD ret; window_ready_event = OpenEventA(EVENT_ALL_ACCESS, FALSE, "test_opw_window"); -- 2.30.2

2 years, 2 months

[PATCH] server: Use a free list for unallocated object handles.

by Zebediah Figura

The Legend of Heroes: Trails of Cold Steel III suffers from an application bug, where it tries to wait on a handle after closing it. Because of the usage patterns of the game and the way Wine allocates handles, the handle is usually reused by a separate object, which is effectively never signaled, resulting in a hang. This patch changes our handle allocation strategy to resemble Windows, and in the process makes the race much less likely, although still theoretically possible. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52461 Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- A more detailed explanation of the bug can be found in the linked bug report. server/handle.c | 125 +++++++++++++++++++++++++----------------------- 1 file changed, 65 insertions(+), 60 deletions(-) diff --git a/server/handle.c b/server/handle.c index bc692b8ebeb..75b1f7969df 100644 --- a/server/handle.c +++ b/server/handle.c @@ -41,8 +41,13 @@ struct handle_entry { - struct object *ptr; /* object */ - unsigned int access; /* access rights */ + union + { + struct object *ptr; /* object */ + struct handle_entry *next; /* next free entry */ + } u; + unsigned int access; /* access rights */ + int used; /* is the entry currently in use? */ }; struct handle_table @@ -51,8 +56,8 @@ struct handle_table struct process *process; /* process owning this table */ int count; /* number of allocated entries */ int last; /* last used entry */ - int free; /* first entry that may be free */ struct handle_entry *entries; /* handle entries */ + struct handle_entry *freelist; /* head of free list */ }; static struct handle_table *global_table; @@ -157,11 +162,11 @@ static void handle_table_dump( struct object *obj, int verbose ) entry = table->entries; for (i = 0; i <= table->last; i++, entry++) { - if (!entry->ptr) continue; + if (!entry->used) continue; fprintf( stderr, " %04x: %p %08x ", - index_to_handle(i), entry->ptr, entry->access ); - dump_object_name( entry->ptr ); - entry->ptr->ops->dump( entry->ptr, 0 ); + index_to_handle(i), entry->u.ptr, entry->access ); + dump_object_name( entry->u.ptr ); + entry->u.ptr->ops->dump( entry->u.ptr, 0 ); } } @@ -176,12 +181,14 @@ static void handle_table_destroy( struct object *obj ) for (i = 0, entry = table->entries; i <= table->last; i++, entry++) { - struct object *obj = entry->ptr; - entry->ptr = NULL; - if (obj) + if (entry->used) { + struct object *obj = entry->u.ptr; if (table->process) obj->ops->close_handle( obj, table->process, index_to_handle(i) ); + entry->used = 0; + entry->u.next = table->freelist; + table->freelist = entry; release_object_from_handle( obj ); } } @@ -208,7 +215,7 @@ struct handle_table *alloc_handle_table( struct process *process, int count ) table->process = process; table->count = count; table->last = -1; - table->free = 0; + table->freelist = NULL; if ((table->entries = mem_alloc( count * sizeof(*table->entries) ))) return table; release_object( table ); return NULL; @@ -234,21 +241,23 @@ static int grow_handle_table( struct handle_table *table ) /* allocate the first free entry in the handle table */ static obj_handle_t alloc_entry( struct handle_table *table, void *obj, unsigned int access ) { - struct handle_entry *entry = table->entries + table->free; - int i; + struct handle_entry *entry; - for (i = table->free; i <= table->last; i++, entry++) if (!entry->ptr) goto found; - if (i >= table->count) + if (table->freelist) { - if (!grow_handle_table( table )) return 0; - entry = table->entries + i; /* the entries may have moved */ + entry = table->freelist; + table->freelist = entry->u.next; } - table->last = i; - found: - table->free = i + 1; - entry->ptr = grab_object_for_handle( obj ); + else + { + if (table->last + 1 >= table->count && !grow_handle_table( table )) return 0; + entry = &table->entries[++table->last]; + } + + entry->used = 1; + entry->u.ptr = grab_object_for_handle( obj ); entry->access = access; - return index_to_handle(i); + return index_to_handle( entry - table->entries ); } /* allocate a handle for an object, incrementing its refcount */ @@ -327,31 +336,10 @@ static struct handle_entry *get_handle( struct process *process, obj_handle_t ha if (index < 0) return NULL; if (index > table->last) return NULL; entry = table->entries + index; - if (!entry->ptr) return NULL; + if (!entry->used) return NULL; return entry; } -/* attempt to shrink a table */ -static void shrink_handle_table( struct handle_table *table ) -{ - struct handle_entry *entry = table->entries + table->last; - struct handle_entry *new_entries; - int count = table->count; - - while (table->last >= 0) - { - if (entry->ptr) break; - table->last--; - entry--; - } - if (table->last >= count / 4) return; /* no need to shrink */ - if (count < MIN_HANDLE_ENTRIES * 2) return; /* too small to shrink */ - count /= 2; - if (!(new_entries = realloc( table->entries, count * sizeof(*new_entries) ))) return; - table->count = count; - table->entries = new_entries; -} - static void inherit_handle( struct process *parent, const obj_handle_t handle, struct handle_table *table ) { struct handle_entry *dst, *src; @@ -362,8 +350,9 @@ static void inherit_handle( struct process *parent, const obj_handle_t handle, s src = get_handle( parent, handle ); if (!src || !(src->access & RESERVED_INHERIT)) return; index = handle_to_index( handle ); - if (dst[index].ptr) return; - grab_object_for_handle( src->ptr ); + if (dst[index].used) return; + + grab_object_for_handle( src->u.ptr ); dst[index] = *src; table->last = max( table->last, index ); } @@ -397,6 +386,18 @@ struct handle_table *copy_handle_table( struct process *process, struct process { inherit_handle( parent, std_handles[i], table ); } + + /* iterate in reverse so that low values are allocated first */ + for (i = table->last; i >= 0; --i) + { + struct handle_entry *entry = &table->entries[i]; + + if (!entry->used) + { + entry->u.next = table->freelist; + table->freelist = entry; + } + } } else { @@ -406,14 +407,16 @@ struct handle_table *copy_handle_table( struct process *process, struct process memcpy( ptr, parent_table->entries, (table->last + 1) * sizeof(struct handle_entry) ); for (i = 0; i <= table->last; i++, ptr++) { - if (!ptr->ptr) continue; - if (ptr->access & RESERVED_INHERIT) grab_object_for_handle( ptr->ptr ); - else ptr->ptr = NULL; /* don't inherit this entry */ + if (ptr->used && (ptr->access & RESERVED_INHERIT)) grab_object_for_handle( ptr->u.ptr ); + else + { + ptr->used = 0; + ptr->u.next = table->freelist; + table->freelist = ptr; + } } } } - /* attempt to shrink the table */ - shrink_handle_table( table ); return table; } @@ -426,12 +429,14 @@ unsigned int close_handle( struct process *process, obj_handle_t handle ) if (!(entry = get_handle( process, handle ))) return STATUS_INVALID_HANDLE; if (entry->access & RESERVED_CLOSE_PROTECT) return STATUS_HANDLE_NOT_CLOSABLE; - obj = entry->ptr; + obj = entry->u.ptr; if (!obj->ops->close_handle( obj, process, handle )) return STATUS_HANDLE_NOT_CLOSABLE; - entry->ptr = NULL; + table = handle_is_global(handle) ? global_table : process->handles; - if (entry < table->entries + table->free) table->free = entry - table->entries; - if (entry == table->entries + table->last) shrink_handle_table( table ); + entry->used = 0; + entry->u.next = table->freelist; + table->freelist = entry; + release_object_from_handle( obj ); return STATUS_SUCCESS; } @@ -471,7 +476,7 @@ struct object *get_handle_obj( struct process *process, obj_handle_t handle, set_error( STATUS_INVALID_HANDLE ); return NULL; } - obj = entry->ptr; + obj = entry->u.ptr; if (ops && (obj->ops != ops)) { set_error( STATUS_OBJECT_TYPE_MISMATCH ); /* not the right type */ @@ -513,8 +518,8 @@ obj_handle_t find_inherited_handle( struct process *process, const struct object for (i = 0, ptr = table->entries; i <= table->last; i++, ptr++) { - if (!ptr->ptr) continue; - if (ptr->ptr->ops != ops) continue; + if (!ptr->used) continue; + if (ptr->u.ptr->ops != ops) continue; if (ptr->access & RESERVED_INHERIT) return index_to_handle(i); } return 0; @@ -825,7 +830,7 @@ static int enum_handles( struct process *process, void *user ) for (i = 0, entry = table->entries; i <= table->last; i++, entry++) { - if (!entry->ptr) continue; + if (!entry->used) continue; if (!info->handle) { info->count++; @@ -836,7 +841,7 @@ static int enum_handles( struct process *process, void *user ) handle->owner = process->id; handle->handle = index_to_handle(i); handle->access = entry->access & ~RESERVED_ALL; - handle->type = entry->ptr->ops->type->index; + handle->type = entry->u.ptr->ops->type->index; handle->attributes = 0; if (entry->access & RESERVED_INHERIT) handle->attributes |= OBJ_INHERIT; if (entry->access & RESERVED_CLOSE_PROTECT) handle->attributes |= OBJ_PROTECT_CLOSE; -- 2.34.1

2 years, 2 months

Arbitrary DOS device name

by Daniel Kucera

Hello all, I have a Windows software which tries to access dos device name but it is failing: 0009:Call KERNEL32.CreateFileA(0060f588 "\\\\.\\d6CDE-0",40000000,00000002,00000000,00000003,00000000,00000000) ret=00b1117f 0009:Call ntdll.RtlInitAnsiString(0060f49c,0060f588 "\\\\.\\d6CDE-0") ret=7b036296 0009:Ret ntdll.RtlInitAnsiString() retval=0060f49c ret=7b036296 0009:Call ntdll.RtlAnsiStringToUnicodeString(3fff8bf8,0060f49c,00000000) ret=7b0362fb 0009:Ret ntdll.RtlAnsiStringToUnicodeString() retval=00000000 ret=7b0362fb 0009:Call ntdll._wcsicmp(3fff8c00 L"\\\\.\\d6CDE-0",7b09d0c0 L"CONIN$") ret=7b0355c9 0009:Ret ntdll._wcsicmp() retval=fffffff9 ret=7b0355c9 0009:Call ntdll._wcsicmp(3fff8c00 L"\\\\.\\d6CDE-0",7b09d0ce L"CONOUT$") ret=7b035636 0009:Ret ntdll._wcsicmp() retval=fffffff9 ret=7b035636 0009:Call ntdll.wcsncmp(3fff8c00 L"\\\\.\\d6CDE-0",7b09d644 L"\\\\.\\",00000004) ret=7b035670 0009:Ret ntdll.wcsncmp() retval=00000000 ret=7b035670 0009:Call ntdll.iswalpha(00000064) ret=7b0356cd 0009:Ret ntdll.iswalpha() retval=00000102 ret=7b0356cd 0009:Call ntdll._wcsnicmp(3fff8c08 L"d6CDE-0",7b09d638 L"PIPE\\",00000005) ret=7b0356f5 0009:Ret ntdll._wcsnicmp() retval=fffffff4 ret=7b0356f5 0009:Call ntdll._wcsnicmp(3fff8c08 L"d6CDE-0",7b09d624 L"MAILSLOT\\",00000009) ret=7b03570e 0009:Ret ntdll._wcsnicmp() retval=fffffff7 ret=7b03570e 0009:Call ntdll.RtlIsDosDeviceName_U(3fff8c08 L"d6CDE-0") ret=7b035724 0009:Ret ntdll.RtlIsDosDeviceName_U() retval=00000000 ret=7b035724 0009:Call ntdll.RtlDosPathNameToNtPathName_U(3fff8c00 L"\\\\.\\d6CDE-0",0060f458,00000000,00000000) ret=7b035769 0009:Ret ntdll.RtlDosPathNameToNtPathName_U() retval=00000001 ret=7b035769 0009:Call ntdll.NtCreateFile(0060f454,40100080,0060f474,0060f460,00000000,00000000,00000002,00000001,00000060,00000000,00000000) ret=7b03581e 0009:Ret ntdll.NtCreateFile() retval=c0000034 ret=7b03581e 0009:Call ntdll.RtlNtStatusToDosError(c0000034) ret=7b035a11 0009:Ret ntdll.RtlNtStatusToDosError() retval=00000002 ret=7b035a11 0009:Call ntdll.RtlFreeUnicodeString(0060f458) ret=7b03592b 0009:Ret ntdll.RtlFreeUnicodeString() retval=0060f458 ret=7b03592b 0009:Ret KERNEL32.CreateFileA() retval=ffffffff ret=00b1117f The problem is, that wine doesn't recognize "\\\\.\\d6CDE-0" as valid DOS device name: https://github.com/wine-mirror/wine/blob/e909986e6ea5ecd49b2b847f321ad89b2a… Even when I created the device in HKEY_LOCAL_MACHINE\Software\Wine\Ports it doesn't allow to open it. When I patched the corresponding DLL to use COM81 and created the device in Ports, it works okay (can open the device). I want to write a patch for ntdll/path.c to recognize my string as DOS device but I want it to be generic enough to be acceptable. What approach do you suggest? Can I add a generic match, something like: "\\\\.\\[^\\]+$" ? To add some context here, the software is for controlling USB osclloscope from Hantek: http://hantek.com/uploadpic/hantek/files/20210731/Hantek-6000_Ver2.2.7_D202… It installs a driver which creates mentioned "DOS device" and communicates through it using ioctl. I am reversing the driver and I'll create a Linux char device to handle those ioctl calls and talk to the USB device using libusb. Thanks. -- S pozdravom / Best regards Daniel Kucera.

2 years, 2 months

[PATCH v2 1/5] include/windows.foundation.collections.idl: Add IVector<T> interface.

by Bernhard Kölbl

Signed-off-by: Bernhard Kölbl <besentv(a)gmail.com> --- v2: Added missing parameters and attributes. This and more incoming patches are part of a bigger branch: https://github.com/besentv/wine-patches/tree/main/windows.media.speech --- include/windows.foundation.collections.idl | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/include/windows.foundation.collections.idl b/include/windows.foundation.collections.idl index 876e15336a2..a2d2d75ec4f 100644 --- a/include/windows.foundation.collections.idl +++ b/include/windows.foundation.collections.idl @@ -118,6 +118,26 @@ cpp_quote("#endif") HRESULT IndexOf([in, optional] T element, [out] UINT32 *index, [out, retval] BOOLEAN *value); HRESULT GetMany([in] UINT32 start_index, [in] UINT32 items_size, [out] T *items, [out, retval] UINT32 *value); } + + [ + contract(Windows.Foundation.FoundationContract, 1.0), + uuid(913337e9-11a1-4345-a3a2-4e7f956e222d) + ] + interface IVector<T> : IInspectable + { + HRESULT GetAt([in, optional] UINT32 index, [out, retval] T *value); + [propget] HRESULT Size([out, retval] UINT32 *value); + HRESULT GetView([out, retval] IVectorView<T> **value); + HRESULT IndexOf([in, optional] T element, [out] UINT32 *index, [out, retval] BOOLEAN *value); + HRESULT SetAt([in] UINT32 index, [in, optional] T value); + HRESULT InsertAt([in] UINT32 index, [in, optional] T value); + HRESULT RemoveAt([in] UINT32 index); + HRESULT Append([in, optional] T value); + HRESULT RemoveAtEnd(); + HRESULT Clear(); + HRESULT GetMany([in] UINT32 start_index, [in] UINT32 items_size, [out] T *items, [out, retval] UINT32 *value); + HRESULT ReplaceAll([in] UINT32 count, [in] T *items); + } } #endif } -- 2.34.1

2 years, 2 months

[PATCH] winemac.drv: fix compile with pre macOS 10.12 SDKs

by Dean Greer

>From 10392f7f4f469f266016542b1d3c0b7d39d59bbc Mon Sep 17 00:00:00 2001 From: Dean M Greer <gcenx83(a)gmail.com> Date: Sun, 23 Jan 2022 13:58:38 -0500 Subject: [PATCH] winemac.drv: fix compile with pre macOS 10.12 SDKs Fixes a regression introduced by https://source.winehq.org/git/wine.git/commit/e58b1a2b395b56859157e7dd8d08c… Signed-off-by: Dean M Greer <gcenx83(a)gmail.com> --- dlls/winemac.drv/cocoa_app.h | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/winemac.drv/cocoa_app.h b/dlls/winemac.drv/cocoa_app.h index e5caad00a870..52c91c0621f1 100644 --- a/dlls/winemac.drv/cocoa_app.h +++ b/dlls/winemac.drv/cocoa_app.h @@ -56,6 +56,7 @@ #define NSWindowStyleMaskResizable NSResizableWindowMask #define NSWindowStyleMaskTitled NSTitledWindowMask #define NSWindowStyleMaskUtilityWindow NSUtilityWindowMask +#define NSWindowStyleMaskNonactivatingPanel NSNonactivatingPanelMask #endif #define ERR(...) do { if (macdrv_err_on) LogError(__func__, __VA_ARGS__); } while (false) --

2 years, 2 months

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel January 2022