ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

combase: Implement local server registration via SCM. 

Main point of this change is to get rid of auxiliary thread that is causing
issues when CoRevokeClassObject() has to wait on it, potentially deadlocking
when called from DllMain.

Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
Signed-off-by: Huw Davies <huw@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Nikolay Sivov 2020-09-02 14:14:49 +03:00 committed by Alexandre Julliard
parent 5d5329936e
commit adfaa93877
6 changed files with 229 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
dlls/combase/combase.c
View File

@ -115,10 +115,6 @@ static CRITICAL_SECTION_DEBUG psclsid_cs_debug =
};
static CRITICAL_SECTION cs_registered_ps = { &psclsid_cs_debug, -1, 0, 0, 0, 0 };
/*
* TODO: Make this data structure aware of inter-process communication. This
* means that parts of this will be exported to rpcss.
*/
struct registered_class
{
struct list entry;
@ -127,8 +123,8 @@ struct registered_class
IUnknown *object;
DWORD clscontext;
DWORD flags;
DWORD cookie;
void *RpcRegistration;
unsigned int cookie;
unsigned int rpcss_cookie;
};
static struct list registered_classes = LIST_INIT(registered_classes);
@ -2824,7 +2820,7 @@ HRESULT WINAPI CoRegisterClassObject(REFCLSID rclsid, IUnknown *object, DWORD cl
return CO_E_OBJISREG;
}
newclass = heap_alloc(sizeof(*newclass));
newclass = heap_alloc_zero(sizeof(*newclass));
if (!newclass)
{
apartment_release(apt);
@ -2835,7 +2831,6 @@ HRESULT WINAPI CoRegisterClassObject(REFCLSID rclsid, IUnknown *object, DWORD cl
newclass->apartment_id = apt->oxid;
newclass->clscontext = clscontext;
newclass->flags = flags;
newclass->RpcRegistration = NULL;
if (!(newclass->cookie = InterlockedIncrement(&next_cookie)))
newclass->cookie = InterlockedIncrement(&next_cookie);
@ -2860,8 +2855,7 @@ HRESULT WINAPI CoRegisterClassObject(REFCLSID rclsid, IUnknown *object, DWORD cl
return hr;
}
hr = rpc_start_local_server(&newclass->clsid, marshal_stream, flags & (REGCLS_MULTIPLEUSE|REGCLS_MULTI_SEPARATE),
&newclass->RpcRegistration);
hr = rpc_register_local_server(&newclass->clsid, marshal_stream, flags, &newclass->rpcss_cookie);
IStream_Release(marshal_stream);
}
@ -2874,12 +2868,28 @@ static void com_revoke_class_object(struct registered_class *entry)
list_remove(&entry->entry);
if (entry->clscontext & CLSCTX_LOCAL_SERVER)
rpc_stop_local_server(entry->RpcRegistration);
rpc_revoke_local_server(entry->rpcss_cookie);
IUnknown_Release(entry->object);
heap_free(entry);
}
/* Cleans up rpcss registry */
static void com_revoke_local_servers(void)
{
struct registered_class *cur, *cur2;
EnterCriticalSection(&registered_classes_cs);
LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &registered_classes, struct registered_class, entry)
{
if (cur->clscontext & CLSCTX_LOCAL_SERVER)
com_revoke_class_object(cur);
}
LeaveCriticalSection(&registered_classes_cs);
}
void apartment_revoke_all_classes(const struct apartment *apt)
{
struct registered_class *cur, *cur2;
@ -3164,6 +3174,7 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID reserved)
hProxyDll = hinstDLL;
break;
case DLL_PROCESS_DETACH:
com_revoke_local_servers();
if (reserved) break;
apartment_global_cleanup();
DeleteCriticalSection(&registered_classes_cs);

4
dlls/combase/combase_private.h
View File

@ -112,8 +112,8 @@ HRESULT apartment_disconnectproxies(struct apartment *apt) DECLSPEC_HIDDEN;
/* RpcSs interface */
HRESULT rpcss_get_next_seqid(DWORD *id) DECLSPEC_HIDDEN;
HRESULT rpc_get_local_class_object(REFCLSID rclsid, REFIID riid, void **obj) DECLSPEC_HIDDEN;
HRESULT rpc_start_local_server(REFCLSID clsid, IStream *stream, BOOL multi_use, void **registration) DECLSPEC_HIDDEN;
void rpc_stop_local_server(void *registration) DECLSPEC_HIDDEN;
HRESULT rpc_register_local_server(REFCLSID clsid, IStream *stream, DWORD flags, unsigned int *cookie) DECLSPEC_HIDDEN;
HRESULT rpc_revoke_local_server(unsigned int cookie) DECLSPEC_HIDDEN;
HRESULT rpc_create_clientchannel(const OXID *oxid, const IPID *ipid, const OXID_INFO *oxid_info, const IID *iid,
DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan, struct apartment *apt) DECLSPEC_HIDDEN;
HRESULT rpc_create_serverchannel(DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan) DECLSPEC_HIDDEN;

290
dlls/combase/rpc.c
View File

@ -363,11 +363,25 @@ HRESULT WINAPI InternalIrotRevoke(IrotCookie cookie, IrotContextHandle *ctxt_han
RPCSS_CALL_END
}
static void get_localserver_pipe_name(WCHAR *pipefn, REFCLSID rclsid)
static HRESULT rpcss_server_register(REFCLSID clsid, DWORD flags, MInterfacePointer *obj, unsigned int *cookie)
{
static const WCHAR wszPipeRef[] = {'\\','\\','.','\\','p','i','p','e','\\',0};
lstrcpyW(pipefn, wszPipeRef);
StringFromGUID2(rclsid, pipefn + ARRAY_SIZE(wszPipeRef) - 1, CHARS_IN_GUID);
RPCSS_CALL_START
hr = irpcss_server_register(get_irpcss_handle(), clsid, flags, obj, cookie);
RPCSS_CALL_END
}
HRESULT rpc_revoke_local_server(unsigned int cookie)
{
RPCSS_CALL_START
hr = irpcss_server_revoke(get_irpcss_handle(), cookie);
RPCSS_CALL_END
}
static HRESULT rpcss_get_class_object(REFCLSID rclsid, PMInterfacePointer *objref)
{
RPCSS_CALL_START
hr = irpcss_get_class_object(get_irpcss_handle(), rclsid, objref);
RPCSS_CALL_END
}
static DWORD start_local_service(const WCHAR *name, DWORD num, LPCWSTR *params)
@ -509,261 +523,103 @@ static HRESULT create_server(REFCLSID rclsid, HANDLE *process)
return S_OK;
}
/* FIXME: should call to rpcss instead */
HRESULT rpc_get_local_class_object(REFCLSID rclsid, REFIID riid, void **obj)
{
HRESULT hr;
HANDLE hPipe;
WCHAR pipefn[100];
DWORD res, bufferlen;
char marshalbuffer[200];
IStream *pStm;
LARGE_INTEGER seekto;
ULARGE_INTEGER newpos;
int tries = 0;
PMInterfacePointer objref = NULL;
IServiceProvider *local_server;
IStream *stream = NULL;
ULARGE_INTEGER newpos;
LARGE_INTEGER seekto;
int tries = 0;
ULONG length;
HRESULT hr;
static const int MAXTRIES = 30; /* 30 seconds */
TRACE("rclsid %s, riid %s\n", debugstr_guid(rclsid), debugstr_guid(riid));
get_localserver_pipe_name(pipefn, rclsid);
TRACE("clsid %s, riid %s\n", debugstr_guid(rclsid), debugstr_guid(riid));
while (tries++ < MAXTRIES)
{
TRACE("waiting for %s\n", debugstr_w(pipefn));
WaitNamedPipeW(pipefn, NMPWAIT_WAIT_FOREVER);
hPipe = CreateFileW(pipefn, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
if (hPipe == INVALID_HANDLE_VALUE)
{
DWORD index;
DWORD start_ticks;
DWORD index, start_ticks;
HANDLE process = 0;
if (SUCCEEDED(hr = rpcss_get_class_object(rclsid, &objref)))
break;
if (tries == 1)
{
if ((hr = create_local_service(rclsid)) && (hr = create_server(rclsid, &process)) )
return hr;
}
else
{
WARN("Connecting to %s, no response yet, retrying: le is %u\n", debugstr_w(pipefn), GetLastError());
}
/* wait for one second, even if messages arrive */
/* Wait for one second, even if messages arrive. */
start_ticks = GetTickCount();
do
{
if (SUCCEEDED(CoWaitForMultipleHandles(0, 1000, (process != 0), &process, &index)) && process && !index)
{
WARN("server for %s failed to start\n", debugstr_guid(rclsid));
CloseHandle( hPipe );
WARN("Server for %s failed to start.\n", debugstr_guid(rclsid));
CloseHandle(process);
return E_NOINTERFACE;
}
} while (GetTickCount() - start_ticks < 1000);
if (process) CloseHandle(process);
continue;
}
bufferlen = 0;
if (!ReadFile(hPipe, marshalbuffer, sizeof(marshalbuffer), &bufferlen, NULL))
{
FIXME("Failed to read marshal id from classfactory of %s.\n", debugstr_guid(rclsid));
CloseHandle(hPipe);
Sleep(1000);
continue;
}
TRACE("read marshal id from pipe\n");
CloseHandle(hPipe);
break;
}
if (tries >= MAXTRIES)
if (!objref || tries >= MAXTRIES)
return E_NOINTERFACE;
hr = CreateStreamOnHGlobal(0, TRUE, &pStm);
if (hr != S_OK) return hr;
hr = IStream_Write(pStm, marshalbuffer, bufferlen, &res);
if (hr != S_OK) goto out;
seekto.u.LowPart = 0;seekto.u.HighPart = 0;
hr = IStream_Seek(pStm, seekto, STREAM_SEEK_SET, &newpos);
TRACE("unmarshalling local server\n");
hr = CoUnmarshalInterface(pStm, &IID_IServiceProvider, (void **)&local_server);
if (SUCCEEDED(hr = CreateStreamOnHGlobal(0, TRUE, &stream)))
hr = IStream_Write(stream, objref->abData, objref->ulCntData, &length);
MIDL_user_free(objref);
if (SUCCEEDED(hr))
{
seekto.QuadPart = 0;
IStream_Seek(stream, seekto, STREAM_SEEK_SET, &newpos);
TRACE("Unmarshalling local server.\n");
hr = CoUnmarshalInterface(stream, &IID_IServiceProvider, (void **)&local_server);
if (SUCCEEDED(hr))
{
hr = IServiceProvider_QueryService(local_server, rclsid, riid, obj);
IServiceProvider_Release(local_server);
out:
IStream_Release(pStm);
}
}
if (stream)
IStream_Release(stream);
return hr;
}
struct local_server_params
HRESULT rpc_register_local_server(REFCLSID clsid, IStream *stream, DWORD flags, unsigned int *cookie)
{
CLSID clsid;
IStream *stream;
HANDLE pipe;
HANDLE stop_event;
HANDLE thread;
BOOL multi_use;
};
MInterfacePointer *obj;
const void *ptr;
HGLOBAL hmem;
SIZE_T size;
HRESULT hr;
/* FIXME: should call to rpcss instead */
static DWORD WINAPI local_server_thread(void *param)
{
struct local_server_params * lsp = param;
WCHAR pipefn[100];
HRESULT hres;
IStream *pStm = lsp->stream;
STATSTG ststg;
unsigned char *buffer;
int buflen;
LARGE_INTEGER seekto;
ULARGE_INTEGER newpos;
ULONG res;
BOOL multi_use = lsp->multi_use;
OVERLAPPED ovl;
HANDLE pipe_event, hPipe = lsp->pipe, new_pipe;
DWORD bytes;
TRACE("%s, %#x\n", debugstr_guid(clsid), flags);
TRACE("Starting threader for %s.\n",debugstr_guid(&lsp->clsid));
hr = GetHGlobalFromStream(stream, &hmem);
if (FAILED(hr)) return hr;
memset(&ovl, 0, sizeof(ovl));
get_localserver_pipe_name(pipefn, &lsp->clsid);
ovl.hEvent = pipe_event = CreateEventW(NULL, FALSE, FALSE, NULL);
while (1) {
if (!ConnectNamedPipe(hPipe, &ovl))
{
DWORD error = GetLastError();
if (error == ERROR_IO_PENDING)
{
HANDLE handles[2] = { pipe_event, lsp->stop_event };
DWORD ret;
ret = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
if (ret != WAIT_OBJECT_0)
break;
}
/* client already connected isn't an error */
else if (error != ERROR_PIPE_CONNECTED)
{
ERR("ConnectNamedPipe failed with error %d\n", GetLastError());
break;
}
}
TRACE("marshalling LocalServer to client\n");
hres = IStream_Stat(pStm,&ststg,STATFLAG_NONAME);
if (hres != S_OK)
break;
seekto.u.LowPart = 0;
seekto.u.HighPart = 0;
hres = IStream_Seek(pStm,seekto,STREAM_SEEK_SET,&newpos);
if (hres != S_OK) {
FIXME("IStream_Seek failed, %x\n",hres);
break;
}
buflen = ststg.cbSize.u.LowPart;
buffer = HeapAlloc(GetProcessHeap(),0,buflen);
hres = IStream_Read(pStm,buffer,buflen,&res);
if (hres != S_OK) {
FIXME("Stream Read failed, %x\n",hres);
HeapFree(GetProcessHeap(),0,buffer);
break;
}
WriteFile(hPipe,buffer,buflen,&res,&ovl);
GetOverlappedResult(hPipe, &ovl, &bytes, TRUE);
HeapFree(GetProcessHeap(),0,buffer);
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
TRACE("done marshalling LocalServer\n");
if (!multi_use)
{
TRACE("single use object, shutting down pipe %s\n", debugstr_w(pipefn));
break;
}
new_pipe = CreateNamedPipeW( pipefn, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_BYTE|PIPE_WAIT, PIPE_UNLIMITED_INSTANCES,
4096, 4096, 500 /* 0.5 second timeout */, NULL );
if (new_pipe == INVALID_HANDLE_VALUE)
{
FIXME("pipe creation failed for %s, le is %u\n", debugstr_w(pipefn), GetLastError());
break;
}
CloseHandle(hPipe);
hPipe = new_pipe;
}
CloseHandle(pipe_event);
CloseHandle(hPipe);
return 0;
}
HRESULT rpc_start_local_server(REFCLSID clsid, IStream *stream, BOOL multi_use, void **registration)
{
DWORD tid, err;
struct local_server_params *lsp;
WCHAR pipefn[100];
lsp = HeapAlloc(GetProcessHeap(), 0, sizeof(*lsp));
if (!lsp)
size = GlobalSize(hmem);
if (!(obj = heap_alloc(FIELD_OFFSET(MInterfacePointer, abData[size]))))
return E_OUTOFMEMORY;
obj->ulCntData = size;
ptr = GlobalLock(hmem);
memcpy(obj->abData, ptr, size);
GlobalUnlock(hmem);
lsp->clsid = *clsid;
lsp->stream = stream;
IStream_AddRef(stream);
lsp->stop_event = CreateEventW(NULL, FALSE, FALSE, NULL);
if (!lsp->stop_event)
{
HeapFree(GetProcessHeap(), 0, lsp);
return HRESULT_FROM_WIN32(GetLastError());
}
lsp->multi_use = multi_use;
hr = rpcss_server_register(clsid, flags, obj, cookie);
get_localserver_pipe_name(pipefn, &lsp->clsid);
lsp->pipe = CreateNamedPipeW(pipefn, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_BYTE|PIPE_WAIT, PIPE_UNLIMITED_INSTANCES,
4096, 4096, 500 /* 0.5 second timeout */, NULL);
if (lsp->pipe == INVALID_HANDLE_VALUE)
{
err = GetLastError();
FIXME("pipe creation failed for %s, le is %u\n", debugstr_w(pipefn), GetLastError());
CloseHandle(lsp->stop_event);
HeapFree(GetProcessHeap(), 0, lsp);
return HRESULT_FROM_WIN32(err);
}
heap_free(obj);
lsp->thread = CreateThread(NULL, 0, local_server_thread, lsp, 0, &tid);
if (!lsp->thread)
{
CloseHandle(lsp->pipe);
CloseHandle(lsp->stop_event);
HeapFree(GetProcessHeap(), 0, lsp);
return HRESULT_FROM_WIN32(GetLastError());
}
*registration = lsp;
return S_OK;
}
void rpc_stop_local_server(void *registration)
{
struct local_server_params *lsp = registration;
/* signal local_server_thread to stop */
SetEvent(lsp->stop_event);
/* wait for it to exit */
WaitForSingleObject(lsp->thread, INFINITE);
IStream_Release(lsp->stream);
CloseHandle(lsp->stop_event);
CloseHandle(lsp->thread);
HeapFree(GetProcessHeap(), 0, lsp);
return hr;
}
static HRESULT unmarshal_ORPCTHAT(RPC_MESSAGE *msg, ORPCTHAT *orpcthat, ORPC_EXTENT_ARRAY *orpc_ext_array,

2
dlls/ole32/compobj.c
View File

@ -29,8 +29,6 @@
*
* TODO list: (items bunched together depend on each other)
*
* - Implement the service control manager (in rpcss) to keep track
* of registered class objects: ISCM::ServerRegisterClsid et al
* - Implement the OXID resolver so we don't need magic endpoint names for
* clients and servers to meet up
*

17
include/wine/irpcss.idl
View File

@ -17,6 +17,7 @@
*/
import "wtypes.idl";
#include "wine/orpc.idl"
cpp_quote("#define IRPCSS_PROTSEQ {'n','c','a','l','r','p','c',0}")
cpp_quote("#define IRPCSS_ENDPOINT {'i','r','p','c','s','s',0}")
@ -27,6 +28,22 @@ cpp_quote("#define IRPCSS_ENDPOINT {'i','r','p','c','s','s',0}")
]
interface Irpcss
{
HRESULT irpcss_server_register(
[in] handle_t handle,
[in] const GUID *clsid,
[in] unsigned int flags,
[in] PMInterfacePointer object,
[out] unsigned int *cookie);
HRESULT irpcss_server_revoke(
[in] handle_t handle,
[in] unsigned int cookie);
HRESULT irpcss_get_class_object(
[in] handle_t handle,
[in] const GUID *clsid,
[out] PMInterfacePointer *object);
HRESULT irpcss_get_thread_seq_id(
[in] handle_t handle,
[out] DWORD *sequence_id);

100
programs/rpcss/rpcss_main.c
View File

@ -31,6 +31,8 @@
#include "irpcss.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/list.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
@ -38,6 +40,104 @@ static WCHAR rpcssW[] = {'R','p','c','S','s',0};
static HANDLE exit_event;
static SERVICE_STATUS_HANDLE service_handle;
struct registered_class
{
struct list entry;
GUID clsid;
unsigned int cookie;
PMInterfacePointer object;
unsigned int single_use : 1;
};
static CRITICAL_SECTION registered_classes_cs = { NULL, -1, 0, 0, 0, 0 };
static struct list registered_classes = LIST_INIT(registered_classes);
HRESULT __cdecl irpcss_server_register(handle_t h, const GUID *clsid, DWORD flags,
PMInterfacePointer object, unsigned int *cookie)
{
struct registered_class *entry;
static int next_cookie;
if (!(entry = heap_alloc_zero(sizeof(*entry))))
return E_OUTOFMEMORY;
entry->clsid = *clsid;
entry->single_use = !(flags & (REGCLS_MULTIPLEUSE | REGCLS_MULTI_SEPARATE));
if (!(entry->object = heap_alloc(FIELD_OFFSET(MInterfacePointer, abData[object->ulCntData]))))
{
heap_free(entry);
return E_OUTOFMEMORY;
}
entry->object->ulCntData = object->ulCntData;
memcpy(&entry->object->abData, object->abData, object->ulCntData);
*cookie = entry->cookie = InterlockedIncrement(&next_cookie);
EnterCriticalSection(&registered_classes_cs);
list_add_tail(&registered_classes, &entry->entry);
LeaveCriticalSection(&registered_classes_cs);
return S_OK;
}
static void scm_revoke_class(struct registered_class *_class)
{
list_remove(&_class->entry);
heap_free(_class->object);
heap_free(_class);
}
HRESULT __cdecl irpcss_server_revoke(handle_t h, unsigned int cookie)
{
struct registered_class *cur;
EnterCriticalSection(&registered_classes_cs);
LIST_FOR_EACH_ENTRY(cur, &registered_classes, struct registered_class, entry)
{
if (cur->cookie == cookie)
{
scm_revoke_class(cur);
break;
}
}
LeaveCriticalSection(&registered_classes_cs);
return S_OK;
}
HRESULT __cdecl irpcss_get_class_object(handle_t h, const GUID *clsid,
PMInterfacePointer *object)
{
struct registered_class *cur;
*object = NULL;
EnterCriticalSection(&registered_classes_cs);
LIST_FOR_EACH_ENTRY(cur, &registered_classes, struct registered_class, entry)
{
if (!memcmp(clsid, &cur->clsid, sizeof(*clsid)))
{
*object = MIDL_user_allocate(FIELD_OFFSET(MInterfacePointer, abData[cur->object->ulCntData]));
if (*object)
{
(*object)->ulCntData = cur->object->ulCntData;
memcpy((*object)->abData, cur->object->abData, cur->object->ulCntData);
}
if (cur->single_use)
scm_revoke_class(cur);
break;
}
}
LeaveCriticalSection(&registered_classes_cs);
return *object ? S_OK : E_NOINTERFACE;
}
HRESULT __cdecl irpcss_get_thread_seq_id(handle_t h, DWORD *id)
{
static LONG thread_seq_id;