ole_server.c File Reference

#include <windows.h>
#include <exdisp.h>
#include <tlhelp32.h>
#include <stdio.h>
#include <assert.h>
#include "wine/test.h"
#include <initguid.h>

Include dependency graph for ole_server.c:

Go to the source code of this file.

Classes
struct	winetest_info
struct	UnknownImpl
struct	ClassFactoryImpl

Macros
#define	COBJMACROS
#define	CONST_VTABLE
#define	GUID_NAME(guid)    { &IID_##guid, #guid }

Functions
	DEFINE_GUID (CLSID_WineTestObject, 0xdeadbeef, 0xdead, 0xbeef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef)
	DEFINE_GUID (CLSID_UnknownUnmarshal, 0x4c1e39e1, 0xe3e3, 0x4296, 0xaa, 0x86, 0xec, 0x93, 0x8d, 0x89, 0x6e, 0x92)
static const char *	debugstr_ole_guid (const GUID *guid)
static UnknownImpl *	impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	UnknownImpl_QueryInterface (IUnknown *iface, REFIID iid, void **ppv)
static ULONG WINAPI	UnknownImpl_AddRef (IUnknown *iface)
static ULONG WINAPI	UnknownImpl_Release (IUnknown *iface)
static ClassFactoryImpl *	impl_from_IClassFactory (IClassFactory *iface)
static HRESULT WINAPI	ClassFactoryImpl_QueryInterface (IClassFactory *iface, REFIID iid, void **ppv)
static ULONG WINAPI	ClassFactoryImpl_AddRef (IClassFactory *iface)
static ULONG WINAPI	ClassFactoryImpl_Release (IClassFactory *iface)
static HRESULT WINAPI	ClassFactoryImpl_CreateInstance (IClassFactory *iface, IUnknown *punkouter, REFIID iid, void **ppv)
static HRESULT WINAPI	ClassFactoryImpl_LockServer (IClassFactory *iface, BOOL lock)
static void	ole_server (void)
static BOOL	register_server (const char *server, BOOL inproc_handler)
static void	unregister_server (void)
static HANDLE	start_server (const char *argv0)
	START_TEST (ole_server)

Variables
struct {
const GUID *   guid
const char *   name
}	guid_name []
static LONG	obj_ref
static LONG	class_ref
static LONG	server_locks
static const IUnknownVtbl	UnknownImpl_Vtbl
static const IClassFactoryVtbl	ClassFactoryImpl_Vtbl
static ClassFactoryImpl	factory = { { &ClassFactoryImpl_Vtbl }, 0 }

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file ole_server.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 22 of file ole_server.c.

GUID_NAME

#define GUID_NAME

(

guid

)

{ &IID_##guid, #guid }

Function Documentation

ClassFactoryImpl_AddRef()

static ULONG WINAPI ClassFactoryImpl_AddRef ( IClassFactory *  iface )

static

Definition at line 172 of file ole_server.c.

{
    ClassFactoryImpl *This = impl_from_IClassFactory(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    InterlockedIncrement(&class_ref);
 
    trace("server: factory_AddRef: %p, ref %lu\n", iface, ref);
    return ref;
}

ClassFactoryImpl_CreateInstance()

static HRESULT WINAPI ClassFactoryImpl_CreateInstance ( IClassFactory *  iface, IUnknown *  punkouter, REFIID  iid, void **  ppv  )

static

Definition at line 194 of file ole_server.c.

{
    UnknownImpl *unknown;
    HRESULT hr;
 
    trace("server: factory_CreateInstance: %p,%s,%p\n", iface, debugstr_ole_guid(iid), ppv);
 
    if (punkouter) return CLASS_E_NOAGGREGATION;
 
    unknown = malloc(sizeof(*unknown));
    if (!unknown) return E_OUTOFMEMORY;
 
    unknown->IUnknown_iface.lpVtbl = &UnknownImpl_Vtbl;
    unknown->ref = 0;
    IUnknown_AddRef(&unknown->IUnknown_iface);
 
    hr = IUnknown_QueryInterface(&unknown->IUnknown_iface, iid, ppv);
    IUnknown_Release(&unknown->IUnknown_iface);
 
    return hr;
}

ClassFactoryImpl_LockServer()

static HRESULT WINAPI ClassFactoryImpl_LockServer ( IClassFactory *  iface, BOOL  lock  )

static

Definition at line 217 of file ole_server.c.

{
    ULONG ref = lock ? InterlockedIncrement(&server_locks) : InterlockedDecrement(&server_locks);
 
    trace("server: factory_LockServer: %p,%d, ref %lu\n", iface, lock, ref);
    return S_OK;
}

ClassFactoryImpl_QueryInterface()

static HRESULT WINAPI ClassFactoryImpl_QueryInterface ( IClassFactory *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 151 of file ole_server.c.

{
    ClassFactoryImpl *This = impl_from_IClassFactory(iface);
 
    trace("server: factory_QueryInterface: %p,%s,%p\n", iface, debugstr_ole_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IClassFactory, iid))
    {
        IClassFactory_AddRef(&This->IClassFactory_iface);
        *ppv = &This->IClassFactory_iface;
        return S_OK;
    }
 
    *ppv = NULL;
    return E_NOINTERFACE;
}

ClassFactoryImpl_Release()

static ULONG WINAPI ClassFactoryImpl_Release ( IClassFactory *  iface )

static

Definition at line 183 of file ole_server.c.

{
    ClassFactoryImpl *This = impl_from_IClassFactory(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    InterlockedDecrement(&class_ref);
 
    trace("server: factory_Release: %p, ref %lu\n", iface, ref);
    return ref;
}

debugstr_ole_guid()

static const char * debugstr_ole_guid ( const GUID *  guid )

static

Definition at line 63 of file ole_server.c.

{
    int i;
 
    if (!guid) return "(null)";
 
    for (i = 0; i < ARRAY_SIZE(guid_name); i++)
    {
        if (IsEqualIID(guid, guid_name[i].guid))
            return guid_name[i].name;
    }
 
    return wine_dbgstr_guid(guid);
}

Referenced by ClassFactoryImpl_CreateInstance(), ClassFactoryImpl_QueryInterface(), and UnknownImpl_QueryInterface().

DEFINE_GUID() [1/2]

DEFINE_GUID	(	CLSID_UnknownUnmarshal	,
		0x4c1e39e1	,
		0xe3e3	,
		0x4296	,
		0xaa	,
		0x86	,
		0xec	,
		0x93	,
		0x8d	,
		0x89	,
		0x6e	,
		0x92
	)

DEFINE_GUID() [2/2]

DEFINE_GUID	(	CLSID_WineTestObject	,
		0xdeadbeef	,
		0xdead	,
		0xbeef	,
		0xde	,
		0xad	,
		0xbe	,
		0xef	,
		0xde	,
		0xad	,
		0xbe	,
		0xef
	)

impl_from_IClassFactory()

static ClassFactoryImpl * impl_from_IClassFactory ( IClassFactory *  iface )

inlinestatic

Definition at line 146 of file ole_server.c.

{
    return CONTAINING_RECORD(iface, ClassFactoryImpl, IClassFactory_iface);
}

Referenced by ClassFactoryImpl_AddRef(), ClassFactoryImpl_QueryInterface(), and ClassFactoryImpl_Release().

impl_from_IUnknown()

static UnknownImpl * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 85 of file ole_server.c.

{
    return CONTAINING_RECORD(iface, UnknownImpl, IUnknown_iface);
}

Referenced by UnknownImpl_AddRef(), UnknownImpl_QueryInterface(), and UnknownImpl_Release().

ole_server()

static void ole_server ( void  )

static

Definition at line 236 of file ole_server.c.

{
    HRESULT hr;
    DWORD key;
 
    trace("server: starting %lu\n", GetCurrentProcessId());
 
    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
    if (hr == S_OK)
    {
        trace("server: registering class object\n");
        hr = CoRegisterClassObject(&CLSID_WineTestObject, (IUnknown *)&factory.IClassFactory_iface,
                                   CLSCTX_SERVER, REGCLS_MULTIPLEUSE, &key);
        if (hr == S_OK)
        {
            HANDLE done_event, init_done_event;
 
            done_event = OpenEventA(SYNCHRONIZE, FALSE, "ole_server_done_event");
            ok(done_event != 0, "server: OpenEvent error %ld\n", GetLastError());
            init_done_event = OpenEventA(EVENT_MODIFY_STATE, FALSE, "ole_server_init_done_event");
            ok(init_done_event != 0, "server: OpenEvent error %ld\n", GetLastError());
 
            SetEvent(init_done_event);
 
            trace("server: waiting for requests\n");
            WaitForSingleObject(done_event, INFINITE);
 
            /* 1 remainining class ref is supposed to be cleared by CoRevokeClassObject */
            ok(class_ref == 1, "expected 1 class refs, got %ld\n", class_ref);
            ok(!obj_ref, "expected 0 object refs, got %ld\n", obj_ref);
            ok(!server_locks, "expected 0 server locks, got %ld\n", server_locks);
 
            CloseHandle(done_event);
            CloseHandle(init_done_event);
            if (0)
            {
                /* calling CoRevokeClassObject terminates process under Win7 */
                trace("call CoRevokeClassObject\n");
                CoRevokeClassObject(key);
                trace("ret CoRevokeClassObject\n");
            }
        }
        trace("server: call CoUninitialize\n");
        CoUninitialize();
        trace("server: ret CoUninitialize\n");
    }
 
    trace("server: exiting %lu\n", GetCurrentProcessId());
}

Referenced by START_TEST().

register_server()

static BOOL register_server ( const char *  server, BOOL  inproc_handler  )

static

Definition at line 287 of file ole_server.c.

{
    static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0};
    DWORD ret;
    HKEY root;
    WCHAR buf[39 + 6];
    char server_path[MAX_PATH];
 
    lstrcpyA(server_path, server);
    lstrcatA(server_path, " ole_server");
 
    lstrcpyW(buf, clsidW);
    StringFromGUID2(&CLSID_WineTestObject, buf + 6, 39);
 
    ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
                          KEY_READ | KEY_WRITE | KEY_CREATE_SUB_KEY, NULL, &root, NULL);
    if (ret == ERROR_SUCCESS)
    {
        ret = RegSetValueA(root, "LocalServer32", REG_SZ, server_path, strlen(server_path));
        ok(ret == ERROR_SUCCESS, "RegSetValue error %lu\n", ret);
 
        if (inproc_handler)
        {
            ret = RegSetValueA(root, "InprocHandler32", REG_SZ, "ole32.dll", 9);
            ok(ret == ERROR_SUCCESS, "RegSetValue error %lu\n", ret);
        }
 
        RegCloseKey(root);
    }
 
    return ret == ERROR_SUCCESS;
}

Referenced by START_TEST().

start_server()

static HANDLE start_server ( const char *  argv0 )

static

Definition at line 344 of file ole_server.c.

{
    PROCESS_INFORMATION pi;
    STARTUPINFOA si;
    SECURITY_ATTRIBUTES sa;
    char cmdline[MAX_PATH * 2];
    BOOL ret;
 
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdInput =  GetStdHandle(STD_INPUT_HANDLE);
    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    si.hStdError = si.hStdOutput;
 
    sa.nLength = sizeof(sa);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;
 
    sprintf(cmdline, "\"%s\" ole_server -server", argv0);
    ret = CreateProcessA(argv0, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
    ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
    if (!ret) return 0;
 
    CloseHandle(pi.hThread);
    return pi.hProcess;
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

ole_server

)

Definition at line 372 of file ole_server.c.

{
    CLSID clsid = CLSID_WineTestObject;
    HRESULT hr;
    IClassFactory *factory;
    IUnknown *unknown;
    IOleObject *oleobj;
    IRunnableObject *runobj;
    DWORD ret;
    HANDLE mapping, done_event, init_done_event, process;
    struct winetest_info *info;
    int argc;
    char **argv;
 
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_ole_server");
    ok(mapping != 0, "CreateFileMapping failed\n");
    info = MapViewOfFile(mapping, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, 4096);
 
    argc = winetest_get_mainargs(&argv);
 
    done_event = CreateEventA(NULL, TRUE, FALSE, "ole_server_done_event");
    ok(done_event != 0, "CreateEvent error %ld\n", GetLastError());
    init_done_event = CreateEventA(NULL, TRUE, FALSE, "ole_server_init_done_event");
    ok(init_done_event != 0, "CreateEvent error %ld\n", GetLastError());
 
    if (argc > 2)
    {
        if (!lstrcmpiA(argv[2], "-Embedding"))
        {
            trace("server: Refusing to be run by ole32\n");
            return;
        }
 
        if (!lstrcmpiA(argv[2], "-server"))
        {
            info->child_failures = 0;
            ole_server();
            info->child_failures = winetest_get_failures();
            return;
        }
 
        trace("server: Unknown parameter: %s\n", argv[2]);
        return;
    }
 
    if (!register_server(argv[0], FALSE))
    {
        win_skip("not enough permissions to create a server CLSID key\n");
        return;
    }
 
    if (!(process = start_server(argv[0])))
    {
        unregister_server();
        return;
    }
    WaitForSingleObject(init_done_event, 5000);
 
    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
    ok(hr == S_OK, "OleInitialize error %#lx\n", hr);
 
    hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&unknown);
    ok(hr == REGDB_E_CLASSNOTREG, "expected REGDB_E_CLASSNOTREG, got %#lx\n", hr);
 
    if (!register_server(argv[0], TRUE))
    {
        win_skip("not enough permissions to create a server CLSID key\n");
        unregister_server();
        return;
    }
 
    trace("call CoCreateInstance(&IID_NULL)\n");
    hr = CoCreateInstance(&clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_NULL, (void **)&unknown);
    trace("ret CoCreateInstance(&IID_NULL)\n");
    ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 
    /* in-process handler supports IID_IUnknown starting from Vista */
    trace("call CoCreateInstance(&IID_IUnknown)\n");
    hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&unknown);
    trace("ret CoCreateInstance(&IID_IUnknown)\n");
    ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG) /* XP,win2000 and earlier */, "CoCreateInstance(IID_IUnknown) error %#lx\n", hr);
    if (hr != S_OK)
    {
        win_skip("In-process handler doesn't support IID_IUnknown on this platform\n");
        goto test_local_server;
    }
 
    trace("call CoCreateInstance(&IID_IOleObject)\n");
    hr = CoCreateInstance(&clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_IOleObject, (void **)&oleobj);
    trace("ret CoCreateInstance(&IID_IOleObject)\n");
    ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 
    trace("call IUnknown_QueryInterface(&IID_IRunnableObject)\n");
    hr = IUnknown_QueryInterface(unknown, &IID_IRunnableObject, (void **)&runobj);
    trace("ret IUnknown_QueryInterface(&IID_IRunnableObject)\n");
    ok(hr == S_OK, "QueryInterface(&IID_IRunnableObject) error %#lx\n", hr);
 
    ret = IRunnableObject_IsRunning(runobj);
    ok(!ret, "expected 0, got %ld\n", ret);
 
    trace("call OleRun\n");
    hr = OleRun(unknown);
    trace("ret OleRun\n");
    todo_wine
    ok(hr == S_OK, "OleRun error %#lx\n", hr);
 
    ret = IRunnableObject_IsRunning(runobj);
    todo_wine
    ok(ret == 1, "expected 1, got %ld\n", ret);
 
    trace("call IRunnableObject_Release\n");
    ret = IRunnableObject_Release(runobj);
    trace("ret IRunnableObject_Release\n");
    ok(ret == 1, "expected ref 1, got %lu\n", ret);
 
    trace("call IUnknown_QueryInterface(&IID_IOleObject)\n");
    hr = IUnknown_QueryInterface(unknown, &IID_IOleObject, (void **)&oleobj);
    trace("ret IUnknown_QueryInterface(&IID_IOleObject)\n");
    ok(hr == S_OK, "QueryInterface(&IID_IOleObject) error %#lx\n", hr);
 
    trace("call IOleObject_Release\n");
    ret = IOleObject_Release(oleobj);
    trace("ret IOleObject_Release\n");
    ok(ret == 1, "expected ref 1, got %lu\n", ret);
 
    trace("call IUnknown_Release\n");
    ret = IUnknown_Release(unknown);
    trace("ret IUnknown_Release\n");
    ok(!ret, "expected ref 0, got %lu\n", ret);
 
test_local_server:
    /* local server supports IID_IUnknown */
    trace("call CoCreateInstance(&IID_IUnknown)\n");
    hr = CoCreateInstance(&clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_IUnknown, (void **)&unknown);
    trace("ret CoCreateInstance(&IID_IUnknown)\n");
    ok(hr == S_OK, "CoCreateInstance(IID_IUnknown) error %#lx\n", hr);
 
    trace("call IUnknown_QueryInterface(&IID_IRunnableObject)\n");
    hr = IUnknown_QueryInterface(unknown, &IID_IRunnableObject, (void **)&runobj);
    trace("ret IUnknown_QueryInterface(&IID_IRunnableObject)\n");
    ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 
    trace("call OleRun\n");
    hr = OleRun(unknown);
    trace("ret OleRun\n");
    ok(hr == S_OK, "OleRun error %#lx\n", hr);
 
    trace("call IUnknown_QueryInterface(&IID_IOleObject)\n");
    hr = IUnknown_QueryInterface(unknown, &IID_IOleObject, (void **)&oleobj);
    trace("ret IUnknown_QueryInterface(&IID_IOleObject)\n");
    ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 
    trace("call IUnknown_Release\n");
    ret = IUnknown_Release(unknown);
    trace("ret IUnknown_Release\n");
    ok(!ret, "expected ref 0, got %lu\n", ret);
 
    trace("call CoGetClassObject(&IID_IClassFactory)\n");
    hr = CoGetClassObject(&clsid, CLSCTX_LOCAL_SERVER, NULL, &IID_IClassFactory, (void **)&factory);
    trace("ret CoGetClassObject(&IID_IClassFactory)\n");
    ok(hr == S_OK, "CoGetClassObject error %#lx\n", hr);
 
    trace("call IClassFactory_CreateInstance(&IID_NULL)\n");
    hr = IClassFactory_CreateInstance(factory, NULL, &IID_NULL, (void **)&oleobj);
    trace("ret IClassFactory_CreateInstance(&IID_NULL)\n");
    ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 
    trace("call IClassFactory_CreateInstance(&IID_IOleObject)\n");
    hr = IClassFactory_CreateInstance(factory, NULL, &IID_IOleObject, (void **)&oleobj);
    trace("ret IClassFactory_CreateInstance(&IID_IOleObject)\n");
    ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 
    trace("call IClassFactory_Release\n");
    ret = IClassFactory_Release(factory);
    trace("ret IClassFactory_Release\n");
    ok(!ret, "expected ref 0, got %lu\n", ret);
 
    trace("signalling termination\n");
    SetEvent(done_event);
    ret = WaitForSingleObject(process, 10000);
    ok(ret == WAIT_OBJECT_0, "server failed to terminate\n");
 
    OleUninitialize();
 
    unregister_server();
 
    if (info->child_failures)
    {
        trace("%ld failures in child process\n", info->child_failures);
        winetest_add_failures(info->child_failures);
    }
}

UnknownImpl_AddRef()

static ULONG WINAPI UnknownImpl_AddRef ( IUnknown *  iface )

static

Definition at line 110 of file ole_server.c.

{
    UnknownImpl *This = impl_from_IUnknown(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    InterlockedIncrement(&obj_ref);
 
    trace("server: unknown_AddRef: %p, ref %lu\n", iface, ref);
    return ref;
}

UnknownImpl_QueryInterface()

static HRESULT WINAPI UnknownImpl_QueryInterface ( IUnknown *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 90 of file ole_server.c.

{
    UnknownImpl *This = impl_from_IUnknown(iface);
 
    trace("server: unknown_QueryInterface: %p,%s,%p\n", iface, debugstr_ole_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid))
    {
        *ppv = &This->IUnknown_iface;
        IUnknown_AddRef(&This->IUnknown_iface);
        return S_OK;
    }
 
    *ppv = NULL;
    return E_NOINTERFACE;
}

UnknownImpl_Release()

static ULONG WINAPI UnknownImpl_Release ( IUnknown *  iface )

static

Definition at line 121 of file ole_server.c.

{
    UnknownImpl *This = impl_from_IUnknown(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    InterlockedDecrement(&obj_ref);
 
    trace("server: unknown_Release: %p, ref %lu\n", iface, ref);
    if (ref == 0) free(This);
    return ref;
}

unregister_server()

static void unregister_server ( void  )

static

Definition at line 320 of file ole_server.c.

{
    static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0};
    DWORD ret;
    HKEY root;
    WCHAR buf[39 + 6];
 
    lstrcpyW(buf, clsidW);
    StringFromGUID2(&CLSID_WineTestObject, buf + 6, 39);
 
    ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
                          DELETE, NULL, &root, NULL);
    if (ret == ERROR_SUCCESS)
    {
        ret = RegDeleteKeyA(root, "InprocHandler32");
        ok(ret == ERROR_SUCCESS, "RegDeleteKey error %lu\n", ret);
        ret = RegDeleteKeyA(root, "LocalServer32");
        ok(ret == ERROR_SUCCESS, "RegDeleteKey error %lu\n", ret);
        ret = RegDeleteKeyA(root, "");
        ok(ret == ERROR_SUCCESS, "RegDeleteKey error %lu\n", ret);
        RegCloseKey(root);
    }
}

Referenced by START_TEST().

Variable Documentation

class_ref

LONG class_ref

static

Definition at line 61 of file ole_server.c.

Referenced by ClassFactoryImpl_AddRef(), ClassFactoryImpl_Release(), and ole_server().

ClassFactoryImpl_Vtbl

const IClassFactoryVtbl ClassFactoryImpl_Vtbl

static

Initial value:

=
{
    ClassFactoryImpl_QueryInterface,
    ClassFactoryImpl_AddRef,
    ClassFactoryImpl_Release,
    ClassFactoryImpl_CreateInstance,
    ClassFactoryImpl_LockServer
}

Definition at line 225 of file ole_server.c.

factory

ClassFactoryImpl factory = { { &ClassFactoryImpl_Vtbl }, 0 }

static

Definition at line 234 of file ole_server.c.

Referenced by START_TEST().

guid

const GUID* guid

Definition at line 42 of file ole_server.c.

Referenced by debugstr_ole_guid().

const struct { ... } guid_name[]

Initial value:

=
{
#define GUID_NAME(guid) 
                          
    GUID_NAME(IUnknown),
    GUID_NAME(IClassFactory),
    GUID_NAME(IOleObject),
    GUID_NAME(IMarshal),
    GUID_NAME(IStdMarshalInfo),
    GUID_NAME(IExternalConnection),
    GUID_NAME(IRunnableObject),
    GUID_NAME(ICallFactory),
    { &CLSID_IdentityUnmarshal, "CLSID_IdentityUnmarshal" },
    { &CLSID_UnknownUnmarshal, "CLSID_UnknownUnmarshal" },
 
}

Referenced by debugstr_ole_guid().

name

const char* name

Definition at line 43 of file ole_server.c.

obj_ref

LONG obj_ref

static

Definition at line 61 of file ole_server.c.

Referenced by ole_server(), UnknownImpl_AddRef(), and UnknownImpl_Release().

server_locks

LONG server_locks

static

Definition at line 61 of file ole_server.c.

Referenced by ClassFactoryImpl_LockServer(), DllCanUnloadNow(), DSCF_LockServer(), and ole_server().

UnknownImpl_Vtbl

const IUnknownVtbl UnknownImpl_Vtbl

static

Initial value:

=
{
    UnknownImpl_QueryInterface,
    UnknownImpl_AddRef,
    UnknownImpl_Release,
}

Definition at line 133 of file ole_server.c.

Referenced by ClassFactoryImpl_CreateInstance().