combase: Implement local server registration via SCM.

dlls/combase/combase.c

@@ -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);

dlls/combase/combase_private.h

@@ -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;

dlls/ole32/compobj.c

@@ -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
  *

include/wine/irpcss.idl

@@ -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);

programs/rpcss/rpcss_main.c

@@ -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;