compobj_private.h File Reference

#include <stdarg.h>
#include "wine/list.h"
#include "wine/heap.h"
#include "windef.h"
#include "winbase.h"
#include "wtypes.h"
#include "dcom.h"
#include "winreg.h"
#include "winternl.h"

Include dependency graph for compobj_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ifstub
struct	stub_manager
struct	ifproxy
struct	apartment
struct	init_spy
struct	oletls

Macros
#define	MSHLFLAGSP_REMUNKNOWN   0x80000000
#define	DM_EXECUTERPC   (WM_USER + 0) /* WPARAM = 0, LPARAM = (struct dispatch_params *) */
#define	DM_HOSTOBJECT   (WM_USER + 1) /* WPARAM = 0, LPARAM = (struct host_object_params *) */
#define	DEBUG_SET_CRITSEC_NAME(cs, name)   (cs)->DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": " name)
#define	DEBUG_CLEAR_CRITSEC_NAME(cs)   (cs)->DebugInfo->Spare[0] = 0
#define	CHARS_IN_GUID   39 /* including NULL */
#define	WINE_CLSCTX_DONT_HOST   0x80000000

Typedefs
typedef struct apartment	APARTMENT
typedef struct LocalServer	LocalServer
typedef enum ifstub_state	STUB_STATE

Enumerations
enum	ifstub_state {   STUBSTATE_NORMAL_MARSHALED , STUBSTATE_NORMAL_UNMARSHALED , STUBSTATE_TABLE_WEAK_MARSHALED , STUBSTATE_TABLE_WEAK_UNMARSHALED ,   STUBSTATE_TABLE_STRONG }

Functions
	DEFINE_OLEGUID (CLSID_DfMarshal, 0x0000030b, 0, 0)
IGlobalInterfaceTable *	get_std_git (void) DECLSPEC_HIDDEN
void	release_std_git (void) DECLSPEC_HIDDEN
HRESULT	StdGlobalInterfaceTable_GetFactory (LPVOID *ppv) DECLSPEC_HIDDEN
HRESULT	COM_OpenKeyForCLSID (REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY *key) DECLSPEC_HIDDEN
HRESULT	COM_OpenKeyForAppIdFromCLSID (REFCLSID clsid, REGSAM access, HKEY *subkey) DECLSPEC_HIDDEN
HRESULT	MARSHAL_GetStandardMarshalCF (LPVOID *ppv) DECLSPEC_HIDDEN
HRESULT	FTMarshalCF_Create (REFIID riid, LPVOID *ppv) DECLSPEC_HIDDEN
ULONG	stub_manager_int_release (struct stub_manager *This) DECLSPEC_HIDDEN
ULONG	stub_manager_ext_addref (struct stub_manager *m, ULONG refs, BOOL tableweak) DECLSPEC_HIDDEN
ULONG	stub_manager_ext_release (struct stub_manager *m, ULONG refs, BOOL tableweak, BOOL last_unlock_releases) DECLSPEC_HIDDEN
struct ifstub *	stub_manager_new_ifstub (struct stub_manager *m, IRpcStubBuffer *sb, REFIID iid, DWORD dest_context, void *dest_context_data, MSHLFLAGS flags) DECLSPEC_HIDDEN
struct ifstub *	stub_manager_find_ifstub (struct stub_manager *m, REFIID iid, MSHLFLAGS flags) DECLSPEC_HIDDEN
struct stub_manager *	get_stub_manager (APARTMENT *apt, OID oid) DECLSPEC_HIDDEN
struct stub_manager *	get_stub_manager_from_object (APARTMENT *apt, IUnknown *object, BOOL alloc) DECLSPEC_HIDDEN
BOOL	stub_manager_notify_unmarshal (struct stub_manager *m, const IPID *ipid) DECLSPEC_HIDDEN
BOOL	stub_manager_is_table_marshaled (struct stub_manager *m, const IPID *ipid) DECLSPEC_HIDDEN
void	stub_manager_release_marshal_data (struct stub_manager *m, ULONG refs, const IPID *ipid, BOOL tableweak) DECLSPEC_HIDDEN
void	stub_manager_disconnect (struct stub_manager *m) DECLSPEC_HIDDEN
HRESULT	ipid_get_dispatch_params (const IPID *ipid, APARTMENT **stub_apt, struct stub_manager **manager, IRpcStubBuffer **stub, IRpcChannelBuffer **chan, IID *iid, IUnknown **iface) DECLSPEC_HIDDEN
HRESULT	start_apartment_remote_unknown (APARTMENT *apt) DECLSPEC_HIDDEN
HRESULT	marshal_object (APARTMENT *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *obj, DWORD dest_context, void *dest_context_data, MSHLFLAGS mshlflags) DECLSPEC_HIDDEN
void	RPC_StartRemoting (struct apartment *apt) DECLSPEC_HIDDEN
HRESULT	RPC_CreateClientChannel (const OXID *oxid, const IPID *ipid, const OXID_INFO *oxid_info, const IID *iid, DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan, APARTMENT *apt) DECLSPEC_HIDDEN
HRESULT	RPC_CreateServerChannel (DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan) DECLSPEC_HIDDEN
void	RPC_ExecuteCall (struct dispatch_params *params) DECLSPEC_HIDDEN
HRESULT	RPC_RegisterInterface (REFIID riid) DECLSPEC_HIDDEN
void	RPC_UnregisterInterface (REFIID riid, BOOL wait) DECLSPEC_HIDDEN
HRESULT	RPC_StartLocalServer (REFCLSID clsid, IStream *stream, BOOL multi_use, void **registration) DECLSPEC_HIDDEN
void	RPC_StopLocalServer (void *registration) DECLSPEC_HIDDEN
HRESULT	RPC_GetLocalClassObject (REFCLSID rclsid, REFIID iid, LPVOID *ppv) DECLSPEC_HIDDEN
HRESULT	RPC_RegisterChannelHook (REFGUID rguid, IChannelHook *hook) DECLSPEC_HIDDEN
void	RPC_UnregisterAllChannelHooks (void) DECLSPEC_HIDDEN
HRESULT	RPC_ResolveOxid (OXID oxid, OXID_INFO *oxid_info) DECLSPEC_HIDDEN
HRESULT WINAPI	RunningObjectTableImpl_Initialize (void) DECLSPEC_HIDDEN
HRESULT WINAPI	RunningObjectTableImpl_UnInitialize (void) DECLSPEC_HIDDEN
void	OLEDD_UnInitialize (void) DECLSPEC_HIDDEN
APARTMENT *	apartment_findfromoxid (OXID oxid, BOOL ref) DECLSPEC_HIDDEN
APARTMENT *	apartment_findfromtid (DWORD tid) DECLSPEC_HIDDEN
DWORD	apartment_release (struct apartment *apt) DECLSPEC_HIDDEN
HRESULT	apartment_disconnectproxies (struct apartment *apt) DECLSPEC_HIDDEN
static HRESULT	apartment_getoxid (const struct apartment *apt, OXID *oxid)
HRESULT	apartment_createwindowifneeded (struct apartment *apt) DECLSPEC_HIDDEN
HWND	apartment_getwindow (const struct apartment *apt) DECLSPEC_HIDDEN
HRESULT	enter_apartment (struct oletls *info, DWORD model) DECLSPEC_HIDDEN
void	leave_apartment (struct oletls *info) DECLSPEC_HIDDEN
APARTMENT *	apartment_get_current_or_mta (void) DECLSPEC_HIDDEN
static struct oletls *	COM_CurrentInfo (void)
static APARTMENT *	COM_CurrentApt (void)
static GUID	COM_CurrentCausalityId (void)
HRESULT WINAPI	OLE32_DllGetClassObject (REFCLSID rclsid, REFIID iid, LPVOID *ppv) DECLSPEC_HIDDEN
HRESULT WINAPI	OLE32_DllRegisterServer (void) DECLSPEC_HIDDEN
HRESULT WINAPI	OLE32_DllUnregisterServer (void) DECLSPEC_HIDDEN
HRESULT	Handler_DllGetClassObject (REFCLSID rclsid, REFIID riid, LPVOID *ppv) DECLSPEC_HIDDEN
HRESULT	HandlerCF_Create (REFCLSID rclsid, REFIID riid, LPVOID *ppv) DECLSPEC_HIDDEN
HRESULT WINAPI	GlobalOptions_CreateInstance (IClassFactory *iface, IUnknown *pUnk, REFIID riid, void **ppv) DECLSPEC_HIDDEN
HRESULT	DataAdviseHolder_OnConnect (IDataAdviseHolder *iface, IDataObject *pDelegate) DECLSPEC_HIDDEN
void	DataAdviseHolder_OnDisconnect (IDataAdviseHolder *iface) DECLSPEC_HIDDEN
LSTATUS	create_classes_key (HKEY, const WCHAR *, REGSAM, HKEY *) DECLSPEC_HIDDEN
LSTATUS	open_classes_key (HKEY, const WCHAR *, REGSAM, HKEY *) DECLSPEC_HIDDEN
BOOL	actctx_get_miscstatus (const CLSID *, DWORD, DWORD *) DECLSPEC_HIDDEN
const char *	debugstr_formatetc (const FORMATETC *formatetc) DECLSPEC_HIDDEN
static HRESULT	copy_formatetc (FORMATETC *dst, const FORMATETC *src)
HRESULT	EnumSTATDATA_Construct (IUnknown *holder, ULONG index, DWORD array_len, STATDATA *data, BOOL copy, IEnumSTATDATA **ppenum) DECLSPEC_HIDDEN

Variables
HINSTANCE hProxyDll	DECLSPEC_HIDDEN

Macro Definition Documentation

CHARS_IN_GUID

#define CHARS_IN_GUID   39 /* including NULL */

Definition at line 303 of file compobj_private.h.

DEBUG_CLEAR_CRITSEC_NAME

#define DEBUG_CLEAR_CRITSEC_NAME

(

cs

)

(cs)->DebugInfo->Spare[0] = 0

Definition at line 301 of file compobj_private.h.

DEBUG_SET_CRITSEC_NAME

#define DEBUG_SET_CRITSEC_NAME	(		cs,
			name
	)		(cs)->DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": " name)

Definition at line 300 of file compobj_private.h.

DM_EXECUTERPC

#define DM_EXECUTERPC   (WM_USER + 0) /* WPARAM = 0, LPARAM = (struct dispatch_params *) */

Definition at line 263 of file compobj_private.h.

DM_HOSTOBJECT

#define DM_HOSTOBJECT   (WM_USER + 1) /* WPARAM = 0, LPARAM = (struct host_object_params *) */

Definition at line 264 of file compobj_private.h.

MSHLFLAGSP_REMUNKNOWN

#define MSHLFLAGSP_REMUNKNOWN   0x80000000

Definition at line 49 of file compobj_private.h.

WINE_CLSCTX_DONT_HOST

#define WINE_CLSCTX_DONT_HOST   0x80000000

Definition at line 305 of file compobj_private.h.

Typedef Documentation

APARTMENT

typedef struct apartment APARTMENT

Definition at line 43 of file compobj_private.h.

LocalServer

typedef struct LocalServer LocalServer

Definition at line 44 of file compobj_private.h.

STUB_STATE

typedef enum ifstub_state STUB_STATE

Enumeration Type Documentation

ifstub_state

enum ifstub_state

Enumerator
STUBSTATE_NORMAL_MARSHALED
STUBSTATE_NORMAL_UNMARSHALED
STUBSTATE_TABLE_WEAK_MARSHALED
STUBSTATE_TABLE_WEAK_UNMARSHALED
STUBSTATE_TABLE_STRONG

Definition at line 64 of file compobj_private.h.

{
    STUBSTATE_NORMAL_MARSHALED,
    STUBSTATE_NORMAL_UNMARSHALED,
    STUBSTATE_TABLE_WEAK_MARSHALED,
    STUBSTATE_TABLE_WEAK_UNMARSHALED,
    STUBSTATE_TABLE_STRONG,
} STUB_STATE;

Function Documentation

actctx_get_miscstatus()

BOOL actctx_get_miscstatus	(	const CLSID *	clsid,
		DWORD	aspect,
		DWORD *	status
	)

Definition at line 254 of file compobj.c.

{
    ACTCTX_SECTION_KEYED_DATA data;
 
    data.cbSize = sizeof(data);
    if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
                              clsid, &data))
    {
        struct comclassredirect_data *comclass = (struct comclassredirect_data*)data.lpData;
        enum comclass_miscfields misc = dvaspect_to_miscfields(aspect);
 
        if (!(comclass->miscmask & misc))
        {
            if (!(comclass->miscmask & MiscStatus))
            {
                *status = 0;
                return TRUE;
            }
            misc = MiscStatus;
        }
 
        switch (misc)
        {
        case MiscStatus:
            *status = comclass->miscstatus;
            break;
        case MiscStatusIcon:
            *status = comclass->miscstatusicon;
            break;
        case MiscStatusContent:
            *status = comclass->miscstatuscontent;
            break;
        case MiscStatusThumbnail:
            *status = comclass->miscstatusthumbnail;
            break;
        case MiscStatusDocPrint:
            *status = comclass->miscstatusdocprint;
            break;
        default:
           ;
        };
 
        return TRUE;
    }
    else
        return FALSE;
}

Referenced by OleRegGetMiscStatus().

apartment_createwindowifneeded()

HRESULT apartment_createwindowifneeded

(

struct apartment *

apt

)

Definition at line 1704 of file compobj.c.

{
    static INIT_ONCE class_init_once = INIT_ONCE_STATIC_INIT;
 
    if (apt->multi_threaded)
        return S_OK;
 
    if (!apt->win)
    {
        HWND hwnd;
 
        InitOnceExecuteOnce( &class_init_once, register_class, NULL, NULL );
 
        hwnd = CreateWindowW(wszAptWinClass, NULL, 0, 0, 0, 0, 0,
                             HWND_MESSAGE, 0, hProxyDll, NULL);
        if (!hwnd)
        {
            ERR("CreateWindow failed with error %d\n", GetLastError());
            return HRESULT_FROM_WIN32(GetLastError());
        }
        if (InterlockedCompareExchangePointer((PVOID *)&apt->win, hwnd, NULL))
            /* someone beat us to it */
            DestroyWindow(hwnd);
    }
 
    return S_OK;
}

Referenced by apartment_get_or_create(), apartment_hostobject_thread(), and marshal_object().

apartment_disconnectproxies()

HRESULT apartment_disconnectproxies

(

struct apartment *

apt

)

Definition at line 1226 of file marshal.c.

{
    struct list * cursor;
 
    LIST_FOR_EACH(cursor, &apt->proxies)
    {
        struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
        proxy_manager_disconnect(proxy);
    }
 
    return S_OK;
}

Referenced by apartment_release().

apartment_findfromoxid()

APARTMENT * apartment_findfromoxid	(	OXID	oxid,
		BOOL	ref
	)

Definition at line 1276 of file compobj.c.

{
    APARTMENT *result = NULL;
    struct list *cursor;
 
    EnterCriticalSection(&csApartment);
    LIST_FOR_EACH( cursor, &apts )
    {
        struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
        if (apt->oxid == oxid)
        {
            result = apt;
            if (ref) apartment_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&csApartment);
 
    return result;
}

Referenced by ipid_to_ifstub(), std_release_marshal_data(), and std_unmarshal_interface().

apartment_findfromtid()

APARTMENT * apartment_findfromtid

(

DWORD

tid

)

Definition at line 1300 of file compobj.c.

{
    APARTMENT *result = NULL;
    struct list *cursor;
 
    EnterCriticalSection(&csApartment);
    LIST_FOR_EACH( cursor, &apts )
    {
        struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
        if (apt->tid == tid)
        {
            result = apt;
            apartment_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&csApartment);
 
    return result;
}

Referenced by ipid_to_ifstub().

apartment_get_current_or_mta()

APARTMENT * apartment_get_current_or_mta

(

void

)

Definition at line 742 of file compobj.c.

{
    APARTMENT *apt = COM_CurrentApt();
    if (apt)
    {
        apartment_addref(apt);
        return apt;
    }
    return apartment_find_mta();
}

Referenced by ClientIdentity_QueryMultipleInterfaces(), ClientRpcChannelBuffer_SendReceive(), CoCreateInstanceEx(), CoDisconnectObject(), CoGetClassObject(), CoGetContextToken(), CoGetPSClsid(), CoLockObjectExternal(), CoRegisterClassObject(), CoRegisterPSClsid(), CoRevokeClassObject(), proxy_manager_get_remunknown(), std_unmarshal_interface(), and StdMarshalImpl_MarshalInterface().

apartment_getoxid()

static HRESULT apartment_getoxid ( const struct apartment *  apt, OXID *  oxid  )

inlinestatic

Definition at line 251 of file compobj_private.h.

{
    *oxid = apt->oxid;
    return S_OK;
}

Referenced by ClientRpcChannelBuffer_IsCorrectApartment(), marshal_object(), RPC_CreateClientChannel(), and std_unmarshal_interface().

apartment_getwindow()

HWND apartment_getwindow

(

const struct apartment *

apt

)

Definition at line 1733 of file compobj.c.

{
    assert(!apt->multi_threaded);
    return apt->win;
}

Referenced by apartment_hostobject_in_hostapt(), apartment_hostobject_thread(), ClientRpcChannelBuffer_GetBuffer(), and dispatch_rpc().

apartment_release()

DWORD apartment_release

(

struct apartment *

apt

)

Definition at line 1172 of file compobj.c.

{
    DWORD ret;
 
    EnterCriticalSection(&csApartment);
 
    ret = InterlockedDecrement(&apt->refs);
    TRACE("%s: after = %d\n", wine_dbgstr_longlong(apt->oxid), ret);
 
    if (apt->being_destroyed)
    {
        LeaveCriticalSection(&csApartment);
        return ret;
    }
 
    /* destruction stuff that needs to happen under csApartment CS */
    if (ret == 0)
    {
        apt->being_destroyed = TRUE;
        if (apt == MTA) MTA = NULL;
        else if (apt == MainApartment) MainApartment = NULL;
        list_remove(&apt->entry);
    }
 
    LeaveCriticalSection(&csApartment);
 
    if (ret == 0)
    {
        struct list *cursor, *cursor2;
 
        TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
 
        if(apt->local_server) {
            LocalServer *local_server = apt->local_server;
            LARGE_INTEGER zero;
 
            memset(&zero, 0, sizeof(zero));
            IStream_Seek(local_server->marshal_stream, zero, STREAM_SEEK_SET, NULL);
            CoReleaseMarshalData(local_server->marshal_stream);
            IStream_Release(local_server->marshal_stream);
            local_server->marshal_stream = NULL;
 
            apt->local_server = NULL;
            local_server->apt = NULL;
            IServiceProvider_Release(&local_server->IServiceProvider_iface);
        }
 
        /* Release the references to the registered class objects */
        COM_RevokeAllClasses(apt);
 
        /* no locking is needed for this apartment, because no other thread
         * can access it at this point */
 
        apartment_disconnectproxies(apt);
 
        if (apt->win) DestroyWindow(apt->win);
        if (apt->host_apt_tid) PostThreadMessageW(apt->host_apt_tid, WM_QUIT, 0, 0);
 
        LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
        {
            struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
            /* release the implicit reference given by the fact that the
             * stub has external references (it must do since it is in the
             * stub manager list in the apartment and all non-apartment users
             * must have a ref on the apartment and so it cannot be destroyed).
             */
            stub_manager_int_release(stubmgr);
        }
 
        /* if this assert fires, then another thread took a reference to a
         * stub manager without taking a reference to the containing
         * apartment, which it must do. */
        assert(list_empty(&apt->stubmgrs));
 
        if (apt->filter) IMessageFilter_Release(apt->filter);
 
        /* free as many unused libraries as possible... */
        apartment_freeunusedlibraries(apt, 0);
 
        /* ... and free the memory for the apartment loaded dll entry and
         * release the dll list reference without freeing the library for the
         * rest */
        while ((cursor = list_head(&apt->loaded_dlls)))
        {
            struct apartment_loaded_dll *apartment_loaded_dll = LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
            COMPOBJ_DllList_ReleaseRef(apartment_loaded_dll->dll, FALSE);
            list_remove(cursor);
            HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
        }
 
        DEBUG_CLEAR_CRITSEC_NAME(&apt->cs);
        DeleteCriticalSection(&apt->cs);
 
        HeapFree(GetProcessHeap(), 0, apt);
    }
 
    return ret;
}

Referenced by apartment_hostobject_in_hostapt(), ClientIdentity_QueryMultipleInterfaces(), ClientRpcChannelBuffer_GetBuffer(), ClientRpcChannelBuffer_SendReceive(), CoCreateInstanceEx(), CoDisconnectObject(), CoGetApartmentType(), CoGetClassObject(), CoGetContextToken(), CoGetPSClsid(), CoLockObjectExternal(), COM_TlsDestroy(), CoRegisterClassObject(), CoRegisterPSClsid(), CoRevokeClassObject(), dispatch_rpc(), ipid_to_ifstub(), leave_apartment(), proxy_manager_get_remunknown(), RemUnknown_RemAddRef(), RemUnknown_RemQueryInterface(), RemUnknown_RemRelease(), std_release_marshal_data(), std_unmarshal_interface(), and StdMarshalImpl_MarshalInterface().

COM_CurrentApt()

static APARTMENT * COM_CurrentApt ( void  )

inlinestatic

Definition at line 284 of file compobj_private.h.

{  
    return COM_CurrentInfo()->apt;
}

Referenced by apartment_get_current_or_mta(), apartment_get_or_create(), apartment_hostobject_thread(), apartment_wndproc(), CoFreeUnusedLibrariesEx(), CoRegisterMessageFilter(), CoWaitForMultipleHandles(), LocalServer_QueryService(), RegisterDragDrop(), and RPC_ExecuteCall().

COM_CurrentCausalityId()

static GUID COM_CurrentCausalityId ( void  )

inlinestatic

Definition at line 289 of file compobj_private.h.

{
    struct oletls *info = COM_CurrentInfo();
    if (!info)
        return GUID_NULL;
    if (IsEqualGUID(&info->causality_id, &GUID_NULL))
        CoCreateGuid(&info->causality_id);
    return info->causality_id;
}

Referenced by ClientRpcChannelBuffer_GetBuffer(), and CoGetCurrentLogicalThreadId().

COM_CurrentInfo()

static struct oletls * COM_CurrentInfo ( void  )

inlinestatic

Definition at line 271 of file compobj_private.h.

{
    if (!NtCurrentTeb()->ReservedForOle)
    {
        struct oletls *oletls = heap_alloc_zero(sizeof(*oletls));
        if (oletls)
            list_init(&oletls->spies);
        NtCurrentTeb()->ReservedForOle = oletls;
    }
 
    return NtCurrentTeb()->ReservedForOle;
}

Referenced by apartment_get_or_create(), ClientRpcChannelBuffer_SendReceive(), CoGetApartmentType(), CoGetCallContext(), CoGetContextToken(), CoGetState(), CoInitializeEx(), COM_CurrentApt(), COM_CurrentCausalityId(), CoRegisterInitializeSpy(), CoRevokeInitializeSpy(), CoSetState(), CoSwitchCallContext(), CoUninitialize(), CoWaitForMultipleHandles(), dispatch_rpc(), get_ole_clipbrd(), GetErrorInfo(), OleInitialize(), OleUninitialize(), RPC_ExecuteCall(), and SetErrorInfo().

COM_OpenKeyForAppIdFromCLSID()

HRESULT COM_OpenKeyForAppIdFromCLSID	(	REFCLSID	clsid,
		REGSAM	access,
		HKEY *	subkey
	)

Definition at line 2480 of file compobj.c.

{
    static const WCHAR szAppId[] = { 'A','p','p','I','d',0 };
    static const WCHAR szAppIdKey[] = { 'A','p','p','I','d','\\',0 };
    DWORD res;
    WCHAR buf[CHARS_IN_GUID];
    WCHAR keyname[ARRAY_SIZE(szAppIdKey) + CHARS_IN_GUID];
    DWORD size;
    HKEY hkey;
    DWORD type;
    HRESULT hr;
 
    /* read the AppID value under the class's key */
    hr = COM_OpenKeyForCLSID(clsid, NULL, KEY_READ, &hkey);
    if (FAILED(hr))
        return hr;
 
    size = sizeof(buf);
    res = RegQueryValueExW(hkey, szAppId, NULL, &type, (LPBYTE)buf, &size);
    RegCloseKey(hkey);
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_KEYMISSING;
    else if (res != ERROR_SUCCESS || type!=REG_SZ)
        return REGDB_E_READREGDB;
 
    lstrcpyW(keyname, szAppIdKey);
    lstrcatW(keyname, buf);
    res = open_classes_key(HKEY_CLASSES_ROOT, keyname, access, subkey);
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_KEYMISSING;
    else if (res != ERROR_SUCCESS)
        return REGDB_E_READREGDB;
 
    return S_OK;
}

Referenced by create_local_service().

COM_OpenKeyForCLSID()

HRESULT COM_OpenKeyForCLSID	(	REFCLSID	clsid,
		LPCWSTR	keyname,
		REGSAM	access,
		HKEY *	key
	)

Definition at line 2448 of file compobj.c.

{
    static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
    WCHAR path[CHARS_IN_GUID + ARRAY_SIZE(wszCLSIDSlash) - 1];
    LONG res;
    HKEY key;
 
    lstrcpyW(path, wszCLSIDSlash);
    StringFromGUID2(clsid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
    res = open_classes_key(HKEY_CLASSES_ROOT, path, keyname ? KEY_READ : access, &key);
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_CLASSNOTREG;
    else if (res != ERROR_SUCCESS)
        return REGDB_E_READREGDB;
 
    if (!keyname)
    {
        *subkey = key;
        return S_OK;
    }
 
    res = open_classes_key(key, keyname, access, subkey);
    RegCloseKey(key);
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_KEYMISSING;
    else if (res != ERROR_SUCCESS)
        return REGDB_E_READREGDB;
 
    return S_OK;
}

Referenced by CoGetClassObject(), CoGetTreatAsClass(), COM_OpenKeyForAppIdFromCLSID(), CoTreatAsClass(), create_server(), Handler_DllGetClassObject(), OleGetAutoConvert(), OleRegEnumVerbs(), OleRegGetMiscStatus(), OleRegGetUserType(), OleSetAutoConvert(), and ProgIDFromCLSID().

copy_formatetc()

static HRESULT copy_formatetc ( FORMATETC *  dst, const FORMATETC *  src  )

inlinestatic

Definition at line 343 of file compobj_private.h.

{
    *dst = *src;
    if (src->ptd)
    {
        dst->ptd = CoTaskMemAlloc( src->ptd->tdSize );
        if (!dst->ptd) return E_OUTOFMEMORY;
        memcpy( dst->ptd, src->ptd, src->ptd->tdSize );
    }
    return S_OK;
}

Referenced by copy_statdata(), DataCache_EnumCache(), init_cache_entry(), and OLEClipbrd_IEnumFORMATETC_Next().

create_classes_key()

LSTATUS create_classes_key	(	HKEY	hkey,
		const WCHAR *	name,
		REGSAM	access,
		HKEY *	retkey
	)

Definition at line 402 of file compobj.c.

{
    OBJECT_ATTRIBUTES attr;
    UNICODE_STRING nameW;
 
    if (!(hkey = get_classes_root_hkey( hkey, access ))) return ERROR_INVALID_HANDLE;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = hkey;
    attr.ObjectName = &nameW;
    attr.Attributes = 0;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    RtlInitUnicodeString( &nameW, name );
 
    return RtlNtStatusToDosError( create_key( retkey, access, &attr ) );
}

Referenced by COMCAT_ICatRegister_RegisterCategories(), COMCAT_RegisterClassCategories(), and get_classes_root_hkey().

DataAdviseHolder_OnConnect()

HRESULT DataAdviseHolder_OnConnect	(	IDataAdviseHolder *	iface,
		IDataObject *	pDelegate
	)

Definition at line 806 of file oleobj.c.

{
  DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
  DWORD index;
  HRESULT hr = S_OK;
 
  for(index = 0; index < This->maxCons; index++)
  {
    if(This->connections[index].pAdvSink != NULL)
    {
      hr = IDataObject_DAdvise(pDelegate, &This->connections[index].formatetc,
                               This->connections[index].advf,
                               This->connections[index].pAdvSink,
                               &This->remote_connections[index]);
      if (FAILED(hr)) break;
      This->connections[index].advf |= WINE_ADVF_REMOTE;
    }
  }
  This->delegate = pDelegate;
  return hr;
}

Referenced by DefaultHandler_DAdvise(), and DefaultHandler_Run().

DataAdviseHolder_OnDisconnect()

void DataAdviseHolder_OnDisconnect

(

IDataAdviseHolder *

iface

)

Definition at line 828 of file oleobj.c.

{
  DataAdviseHolder *This = impl_from_IDataAdviseHolder(iface);
  DWORD index;
 
  for(index = 0; index < This->maxCons; index++)
  {
    if((This->connections[index].pAdvSink != NULL) &&
       (This->connections[index].advf & WINE_ADVF_REMOTE))
    {
      IDataObject_DUnadvise(This->delegate, This->remote_connections[index]);
      This->remote_connections[index] = 0;
      This->connections[index].advf &= ~WINE_ADVF_REMOTE;
    }
  }
  This->delegate = NULL;
}

Referenced by DefaultHandler_Stop().

debugstr_formatetc()

const char * debugstr_formatetc

(

const FORMATETC *

formatetc

)

Definition at line 216 of file datacache.c.

{
    return wine_dbg_sprintf("{ cfFormat = 0x%x, ptd = %p, dwAspect = %d, lindex = %d, tymed = %d }",
        formatetc->cfFormat, formatetc->ptd, formatetc->dwAspect,
        formatetc->lindex, formatetc->tymed);
}

Referenced by add_cache_entry(), DataCache_Cache(), DataCache_GetData(), DataCache_IOleCache2_SetData(), DataCache_OnDataChange(), DataCache_QueryGetData(), DataCacheEntry_Save(), and OleCreateFromFileEx().

DEFINE_OLEGUID()

DEFINE_OLEGUID	(	CLSID_DfMarshal	,
		0x0000030b	,
		0	,
		0
	)

enter_apartment()

HRESULT enter_apartment	(	struct oletls *	info,
		DWORD	model
	)

Definition at line 1913 of file compobj.c.

{
    HRESULT hr = S_OK;
 
    if (!info->apt)
    {
        if (!apartment_get_or_create( model ))
            return E_OUTOFMEMORY;
    }
    else if (!apartment_is_model( info->apt, model ))
    {
        WARN( "Attempt to change threading model of this apartment from %s to %s\n",
              info->apt->multi_threaded ? "multi-threaded" : "apartment threaded",
              model & COINIT_APARTMENTTHREADED ? "apartment threaded" : "multi-threaded" );
        return RPC_E_CHANGED_MODE;
    }
    else
        hr = S_FALSE;
 
    info->inits++;
 
    return hr;
}

Referenced by CoInitializeEx(), and dispatch_rpc().

EnumSTATDATA_Construct()

HRESULT EnumSTATDATA_Construct	(	IUnknown *	holder,
		ULONG	index,
		DWORD	array_len,
		STATDATA *	data,
		BOOL	copy,
		IEnumSTATDATA **	ppenum
	)

Definition at line 197 of file oleobj.c.

{
    EnumSTATDATA *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    DWORD i, count;
 
    if (!This) return E_OUTOFMEMORY;
 
    This->IEnumSTATDATA_iface.lpVtbl = &EnumSTATDATA_VTable;
    This->ref = 1;
    This->index = index;
 
    if (copy)
    {
        This->statdata = HeapAlloc(GetProcessHeap(), 0, array_len * sizeof(*This->statdata));
        if(!This->statdata)
        {
            HeapFree(GetProcessHeap(), 0, This);
            return E_OUTOFMEMORY;
        }
 
        for(i = 0, count = 0; i < array_len; i++)
        {
            if(data[i].pAdvSink)
            {
                copy_statdata(This->statdata + count, data + i);
                count++;
            }
        }
    }
    else
    {
        This->statdata = data;
        count = array_len;
    }
 
    This->num_of_elems = count;
    This->holder = holder;
    if (holder) IUnknown_AddRef(holder);
    *ppenum = &This->IEnumSTATDATA_iface;
    return S_OK;
}

Referenced by DataAdviseHolder_EnumAdvise(), DataCache_EnumCache(), EnumSTATDATA_Clone(), and OleAdviseHolderImpl_EnumAdvise().

FTMarshalCF_Create()

HRESULT FTMarshalCF_Create	(	REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 411 of file ftmarshal.c.

{
    return IClassFactory_QueryInterface((IClassFactory *)&FTMarshalCF, riid, ppv);
}

Referenced by CoGetClassObject().

get_std_git()

IGlobalInterfaceTable * get_std_git

(

void

)

Definition at line 362 of file git.c.

{
  if (!std_git)
  {
    StdGlobalInterfaceTableImpl* newGIT;
 
    newGIT = HeapAlloc(GetProcessHeap(), 0, sizeof(StdGlobalInterfaceTableImpl));
    if (!newGIT) return NULL;
 
    newGIT->IGlobalInterfaceTable_iface.lpVtbl = &StdGlobalInterfaceTableImpl_Vtbl;
    list_init(&newGIT->list);
    newGIT->nextCookie = 0xf100; /* that's where windows starts, so that's where we start */
 
    if (InterlockedCompareExchangePointer((void**)&std_git, &newGIT->IGlobalInterfaceTable_iface, NULL))
    {
      HeapFree(GetProcessHeap(), 0, newGIT);
    }
    else
      TRACE("Created the GIT at %p\n", newGIT);
  }
 
  return std_git;
}

Referenced by CoCreateInstanceEx(), and GITCF_CreateInstance().

get_stub_manager()

struct stub_manager * get_stub_manager	(	APARTMENT *	apt,
		OID	oid
	)

Definition at line 380 of file stubmanager.c.

{
    struct stub_manager *result = NULL;
    struct list         *cursor;
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH( cursor, &apt->stubmgrs )
    {
        struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 
        if (m->oid == oid)
        {
            result = m;
            stub_manager_int_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&apt->cs);
 
    if (result)
        TRACE("found %p for oid %s\n", result, wine_dbgstr_longlong(oid));
    else
        TRACE("not found for oid %s\n", wine_dbgstr_longlong(oid));
 
    return result;
}

Referenced by std_release_marshal_data(), and std_unmarshal_interface().

get_stub_manager_from_object()

struct stub_manager * get_stub_manager_from_object	(	APARTMENT *	apt,
		IUnknown *	object,
		BOOL	alloc
	)

Definition at line 337 of file stubmanager.c.

{
    struct stub_manager *result = NULL;
    struct list         *cursor;
    IUnknown *object;
    HRESULT hres;
 
    hres = IUnknown_QueryInterface(obj, &IID_IUnknown, (void**)&object);
    if (FAILED(hres)) {
        ERR("QueryInterface(IID_IUnknown failed): %08x\n", hres);
        return NULL;
    }
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH( cursor, &apt->stubmgrs )
    {
        struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 
        if (m->object == object)
        {
            result = m;
            stub_manager_int_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&apt->cs);
 
    if (result) {
        TRACE("found %p for object %p\n", result, object);
    }else if (alloc) {
        TRACE("not found, creating new stub manager...\n");
        result = new_stub_manager(apt, object);
    }else {
        TRACE("not found for object %p\n", object);
    }
 
    IUnknown_Release(object);
    return result;    
}

Referenced by CoDisconnectObject(), CoLockObjectExternal(), and marshal_object().

GlobalOptions_CreateInstance()

HRESULT WINAPI GlobalOptions_CreateInstance	(	IClassFactory *	iface,
		IUnknown *	pUnk,
		REFIID	riid,
		void **	ppv
	)

Definition at line 5351 of file compobj.c.

{
    GlobalOptions *global_options;
    HRESULT hres;
 
    TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 
    if (outer)
        return E_INVALIDARG;
 
    global_options = heap_alloc(sizeof(*global_options));
    if (!global_options)
        return E_OUTOFMEMORY;
    global_options->IGlobalOptions_iface.lpVtbl = &GlobalOptionsVtbl;
    global_options->ref = 1;
 
    hres = IGlobalOptions_QueryInterface(&global_options->IGlobalOptions_iface, riid, ppv);
    IGlobalOptions_Release(&global_options->IGlobalOptions_iface);
    return hres;
}

Handler_DllGetClassObject()

HRESULT Handler_DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 5167 of file compobj.c.

{
    static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
    HKEY hkey;
    HRESULT hres;
 
    hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
    if (SUCCEEDED(hres))
    {
        struct class_reg_data regdata;
        WCHAR dllpath[MAX_PATH+1];
 
        regdata.u.hkey = hkey;
        regdata.hkey = TRUE;
 
        if (get_object_dll_path(&regdata, dllpath, ARRAY_SIZE(dllpath)))
        {
            static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
            if (!wcsicmp(dllpath, wszOle32))
            {
                RegCloseKey(hkey);
                return HandlerCF_Create(rclsid, riid, ppv);
            }
        }
        else
            WARN("not creating object for inproc handler path %s\n", debugstr_w(dllpath));
        RegCloseKey(hkey);
    }
 
    return CLASS_E_CLASSNOTAVAILABLE;
}

Referenced by DllGetClassObject().

HandlerCF_Create()

HRESULT HandlerCF_Create	(	REFCLSID	rclsid,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 2358 of file defaulthandler.c.

{
    HRESULT hr;
    HandlerCF *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
    This->IClassFactory_iface.lpVtbl = &HandlerClassFactoryVtbl;
    This->refs = 0;
    This->clsid = *rclsid;
 
    hr = IClassFactory_QueryInterface(&This->IClassFactory_iface, riid, ppv);
    if (FAILED(hr))
        HeapFree(GetProcessHeap(), 0, This);
 
    return hr;
}

Referenced by Handler_DllGetClassObject().

ipid_get_dispatch_params()

HRESULT ipid_get_dispatch_params	(	const IPID *	ipid,
		APARTMENT **	stub_apt,
		struct stub_manager **	manager,
		IRpcStubBuffer **	stub,
		IRpcChannelBuffer **	chan,
		IID *	iid,
		IUnknown **	iface
	)

Definition at line 533 of file stubmanager.c.

{
    struct stub_manager *stubmgr;
    struct ifstub *ifstub;
    APARTMENT *apt;
    HRESULT hr;
 
    hr = ipid_to_ifstub(ipid, &apt, &stubmgr, &ifstub);
    if (hr != S_OK) return RPC_E_DISCONNECTED;
 
    *stub = ifstub->stubbuffer;
    IRpcStubBuffer_AddRef(*stub);
    *chan = ifstub->chan;
    IRpcChannelBuffer_AddRef(*chan);
    *stub_apt = apt;
    *iid = ifstub->iid;
    *iface = ifstub->iface;
 
    if (manager)
        *manager = stubmgr;
    else
        stub_manager_int_release(stubmgr);
    return S_OK;
}

Referenced by ClientRpcChannelBuffer_GetBuffer(), and dispatch_rpc().

leave_apartment()

void leave_apartment

(

struct oletls *

info

)

Definition at line 1937 of file compobj.c.

{
    if (!--info->inits)
    {
        if (info->ole_inits)
            WARN( "Uninitializing apartment while Ole is still initialized\n" );
        apartment_release( info->apt );
        info->apt = NULL;
    }
}

Referenced by CoUninitialize(), and dispatch_rpc().

MARSHAL_GetStandardMarshalCF()

HRESULT MARSHAL_GetStandardMarshalCF

(

LPVOID *

ppv

)

Definition at line 2205 of file marshal.c.

{
    *ppv = &StdMarshalCF;
    return S_OK;
}

Referenced by DllGetClassObject().

marshal_object()

HRESULT marshal_object	(	APARTMENT *	apt,
		STDOBJREF *	stdobjref,
		REFIID	riid,
		IUnknown *	obj,
		DWORD	dest_context,
		void *	dest_context_data,
		MSHLFLAGS	mshlflags
	)

Definition at line 121 of file marshal.c.

{
    struct stub_manager *manager;
    struct ifstub       *ifstub;
    BOOL                 tablemarshal;
    HRESULT              hr;
 
    hr = apartment_getoxid(apt, &stdobjref->oxid);
    if (hr != S_OK)
        return hr;
 
    hr = apartment_createwindowifneeded(apt);
    if (hr != S_OK)
        return hr;
 
    if (!(manager = get_stub_manager_from_object(apt, object, TRUE)))
        return E_OUTOFMEMORY;
 
    stdobjref->flags = SORF_NULL;
    if (mshlflags & MSHLFLAGS_TABLEWEAK)
        stdobjref->flags |= SORFP_TABLEWEAK;
    if (mshlflags & MSHLFLAGS_NOPING)
        stdobjref->flags |= SORF_NOPING;
    stdobjref->oid = manager->oid;
 
    tablemarshal = ((mshlflags & MSHLFLAGS_TABLESTRONG) || (mshlflags & MSHLFLAGS_TABLEWEAK));
 
    /* make sure ifstub that we are creating is unique */
    ifstub = stub_manager_find_ifstub(manager, riid, mshlflags);
    if (!ifstub) {
        IRpcStubBuffer *stub = NULL;
 
        /* IUnknown doesn't require a stub buffer, because it never goes out on
         * the wire */
        if (!IsEqualIID(riid, &IID_IUnknown))
        {
            IPSFactoryBuffer *psfb;
 
            hr = get_facbuf_for_iid(riid, &psfb);
            if (hr == S_OK) {
                hr = IPSFactoryBuffer_CreateStub(psfb, riid, manager->object, &stub);
                IPSFactoryBuffer_Release(psfb);
                if (hr != S_OK)
                    ERR("Failed to create an IRpcStubBuffer from IPSFactory for %s with error 0x%08x\n",
                        debugstr_guid(riid), hr);
            }else {
                ERR("couldn't get IPSFactory buffer for interface %s\n", debugstr_guid(riid));
                hr = E_NOINTERFACE;
            }
 
        }
 
        if (hr == S_OK) {
            ifstub = stub_manager_new_ifstub(manager, stub, riid, dest_context, dest_context_data, mshlflags);
            if (!ifstub)
                hr = E_OUTOFMEMORY;
        }
        if (stub) IRpcStubBuffer_Release(stub);
 
        if (hr != S_OK) {
            stub_manager_int_release(manager);
            /* destroy the stub manager if it has no ifstubs by releasing
             * zero external references */
            stub_manager_ext_release(manager, 0, FALSE, TRUE);
            return hr;
        }
    }
 
    if (!tablemarshal)
    {
        stdobjref->cPublicRefs = NORMALEXTREFS;
        stub_manager_ext_addref(manager, stdobjref->cPublicRefs, FALSE);
    }
    else
    {
        stdobjref->cPublicRefs = 0;
        if (mshlflags & MSHLFLAGS_TABLESTRONG)
            stub_manager_ext_addref(manager, 1, FALSE);
        else
            stub_manager_ext_addref(manager, 0, TRUE);
    }
 
    /* FIXME: check return value */
    RPC_RegisterInterface(riid);
 
    stdobjref->ipid = ifstub->ipid;
 
    stub_manager_int_release(manager);
    return S_OK;
}

Referenced by RemUnknown_RemQueryInterface(), start_apartment_remote_unknown(), and StdMarshalImpl_MarshalInterface().

OLE32_DllGetClassObject()

HRESULT WINAPI OLE32_DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	iid,
		LPVOID *	ppv
	)

Referenced by DllGetClassObject().

OLE32_DllRegisterServer()

HRESULT WINAPI OLE32_DllRegisterServer

(

void

)

Referenced by DllRegisterServer().

OLE32_DllUnregisterServer()

HRESULT WINAPI OLE32_DllUnregisterServer

(

void

)

Referenced by DllUnregisterServer().

OLEDD_UnInitialize()

void OLEDD_UnInitialize

(

void

)

open_classes_key()

LSTATUS open_classes_key	(	HKEY	hkey,
		const WCHAR *	name,
		REGSAM	access,
		HKEY *	retkey
	)

Definition at line 420 of file compobj.c.

{
    OBJECT_ATTRIBUTES attr;
    UNICODE_STRING nameW;
 
    if (!(hkey = get_classes_root_hkey( hkey, access ))) return ERROR_INVALID_HANDLE;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = hkey;
    attr.ObjectName = &nameW;
    attr.Attributes = 0;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    RtlInitUnicodeString( &nameW, name );
 
    return RtlNtStatusToDosError( NtOpenKey( (HANDLE *)retkey, access, &attr ) );
}

Referenced by CATIDEnumGUID_Clone(), CATIDEnumGUID_Construct(), clsid_from_string_reg(), CLSIDEnumGUID_Clone(), CLSIDEnumGUID_Construct(), CLSIDEnumGUID_Next(), COM_OpenKeyForAppIdFromCLSID(), COM_OpenKeyForCLSID(), COMCAT_ICatInformation_GetCategoryDesc(), COMCAT_ICatInformation_IsClassOfCategories(), COMCAT_ICatRegister_UnRegisterCategories(), COMCAT_IEnumCATEGORYINFO_Clone(), COMCAT_IEnumCATEGORYINFO_Next(), COMCAT_IsClassOfCategories(), COMCAT_UnRegisterClassCategories(), EnumCATEGORYINFO_Construct(), get_ps_clsid_from_registry(), OLECONVERT_CreateCompObjStream(), and OleRegGetMiscStatus().

release_std_git()

void release_std_git

(

void

)

Definition at line 386 of file git.c.

{
  StdGlobalInterfaceTableImpl *git;
  StdGITEntry *entry, *entry2;
 
  if (!std_git) return;
 
  git = impl_from_IGlobalInterfaceTable(std_git);
  LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &git->list, StdGITEntry, entry)
  {
      list_remove(&entry->entry);
 
      CoReleaseMarshalData(entry->stream);
      IStream_Release(entry->stream);
      HeapFree(GetProcessHeap(), 0, entry);
  }
 
  HeapFree(GetProcessHeap(), 0, git);
}

Referenced by DllMain().

RPC_CreateClientChannel()

HRESULT RPC_CreateClientChannel	(	const OXID *	oxid,
		const IPID *	ipid,
		const OXID_INFO *	oxid_info,
		const IID *	iid,
		DWORD	dest_context,
		void *	dest_context_data,
		IRpcChannelBuffer **	chan,
		APARTMENT *	apt
	)

Definition at line 1095 of file rpc.c.

{
    ClientRpcChannelBuffer *This;
    WCHAR                   endpoint[200];
    RPC_BINDING_HANDLE      bind;
    RPC_STATUS              status;
    LPWSTR                  string_binding;
 
    /* FIXME: get the endpoint from oxid_info->psa instead */
    get_rpc_endpoint(endpoint, oxid);
 
    TRACE("proxy pipe: connecting to endpoint: %s\n", debugstr_w(endpoint));
 
    status = RpcStringBindingComposeW(
        NULL,
        wszRpcTransport,
        NULL,
        endpoint,
        NULL,
        &string_binding);
        
    if (status == RPC_S_OK)
    {
        status = RpcBindingFromStringBindingW(string_binding, &bind);
 
        if (status == RPC_S_OK)
        {
            IPID ipid2 = *ipid; /* why can't RpcBindingSetObject take a const? */
            status = RpcBindingSetObject(bind, &ipid2);
            if (status != RPC_S_OK)
                RpcBindingFree(&bind);
        }
 
        RpcStringFreeW(&string_binding);
    }
 
    if (status != RPC_S_OK)
    {
        ERR("Couldn't get binding for endpoint %s, status = %d\n", debugstr_w(endpoint), status);
        return HRESULT_FROM_WIN32(status);
    }
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This)
    {
        RpcBindingFree(&bind);
        return E_OUTOFMEMORY;
    }
 
    This->super.IRpcChannelBuffer_iface.lpVtbl = &ClientRpcChannelBufferVtbl;
    This->super.refs = 1;
    This->super.dest_context = dest_context;
    This->super.dest_context_data = dest_context_data;
    This->bind = bind;
    apartment_getoxid(apt, &This->oxid);
    This->server_pid = oxid_info->dwPid;
    This->event = NULL;
    This->iid = *iid;
 
    *chan = &This->super.IRpcChannelBuffer_iface;
 
    return S_OK;
}

Referenced by unmarshal_object().

RPC_CreateServerChannel()

HRESULT RPC_CreateServerChannel	(	DWORD	dest_context,
		void *	dest_context_data,
		IRpcChannelBuffer **	chan
	)

Definition at line 1162 of file rpc.c.

{
    RpcChannelBuffer *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IRpcChannelBuffer_iface.lpVtbl = &ServerRpcChannelBufferVtbl;
    This->refs = 1;
    This->dest_context = dest_context;
    This->dest_context_data = dest_context_data;
    
    *chan = &This->IRpcChannelBuffer_iface;
 
    return S_OK;
}

Referenced by stub_manager_new_ifstub().

RPC_ExecuteCall()

void RPC_ExecuteCall

(

struct dispatch_params *

params

)

Definition at line 1327 of file rpc.c.

{
    struct message_state *message_state = NULL;
    RPC_MESSAGE *msg = (RPC_MESSAGE *)params->msg;
    char *original_buffer = msg->Buffer;
    ORPCTHIS orpcthis;
    ORPC_EXTENT_ARRAY orpc_ext_array;
    WIRE_ORPC_EXTENT *first_wire_orpc_extent;
    GUID old_causality_id;
 
    /* handle ORPCTHIS and server extensions */
 
    params->hr = unmarshal_ORPCTHIS(msg, &orpcthis, &orpc_ext_array, &first_wire_orpc_extent);
    if (params->hr != S_OK)
    {
        msg->Buffer = original_buffer;
        goto exit;
    }
 
    message_state = HeapAlloc(GetProcessHeap(), 0, sizeof(*message_state));
    if (!message_state)
    {
        params->hr = E_OUTOFMEMORY;
        msg->Buffer = original_buffer;
        goto exit;
    }
 
    message_state->prefix_data_len = (char *)msg->Buffer - original_buffer;
    message_state->binding_handle = msg->Handle;
    message_state->bypass_rpcrt = params->bypass_rpcrt;
 
    message_state->channel_hook_info.iid = params->iid;
    message_state->channel_hook_info.cbSize = sizeof(message_state->channel_hook_info);
    message_state->channel_hook_info.uCausality = orpcthis.cid;
    message_state->channel_hook_info.dwServerPid = GetCurrentProcessId();
    message_state->channel_hook_info.iMethod = msg->ProcNum;
    message_state->channel_hook_info.pObject = params->iface;
 
    if (orpcthis.extensions && first_wire_orpc_extent &&
        orpcthis.extensions->size)
        ChannelHooks_ServerNotify(&message_state->channel_hook_info, msg->DataRepresentation, first_wire_orpc_extent, orpcthis.extensions->size);
 
    msg->Handle = message_state;
    msg->BufferLength -= message_state->prefix_data_len;
 
    /* call message filter */
 
    if (COM_CurrentApt()->filter)
    {
        DWORD handlecall;
        INTERFACEINFO interface_info;
        CALLTYPE calltype;
 
        interface_info.pUnk = params->iface;
        interface_info.iid = params->iid;
        interface_info.wMethod = msg->ProcNum;
 
        if (IsEqualGUID(&orpcthis.cid, &COM_CurrentInfo()->causality_id))
            calltype = CALLTYPE_NESTED;
        else if (COM_CurrentInfo()->pending_call_count_server == 0)
            calltype = CALLTYPE_TOPLEVEL;
        else
            calltype = CALLTYPE_TOPLEVEL_CALLPENDING;
 
        handlecall = IMessageFilter_HandleInComingCall(COM_CurrentApt()->filter,
                                                       calltype,
                                                       UlongToHandle(GetCurrentProcessId()),
                                                       0 /* FIXME */,
                                                       &interface_info);
        TRACE("IMessageFilter_HandleInComingCall returned %d\n", handlecall);
        switch (handlecall)
        {
        case SERVERCALL_REJECTED:
            params->hr = RPC_E_CALL_REJECTED;
            goto exit_reset_state;
        case SERVERCALL_RETRYLATER:
#if 0 /* FIXME: handle retries on the client side before enabling this code */
            params->hr = RPC_E_RETRY;
            goto exit_reset_state;
#else
            FIXME("retry call later not implemented\n");
            break;
#endif
        case SERVERCALL_ISHANDLED:
        default:
            break;
        }
    }
 
    /* invoke the method */
 
    /* save the old causality ID - note: any calls executed while processing
     * messages received during the SendReceive will appear to originate from
     * this call - this should be checked with what Windows does */
    old_causality_id = COM_CurrentInfo()->causality_id;
    COM_CurrentInfo()->causality_id = orpcthis.cid;
    COM_CurrentInfo()->pending_call_count_server++;
    params->hr = IRpcStubBuffer_Invoke(params->stub, params->msg, params->chan);
    COM_CurrentInfo()->pending_call_count_server--;
    COM_CurrentInfo()->causality_id = old_causality_id;
 
    /* the invoke allocated a new buffer, so free the old one */
    if (message_state->bypass_rpcrt && original_buffer != msg->Buffer)
        HeapFree(GetProcessHeap(), 0, original_buffer);
 
exit_reset_state:
    message_state = msg->Handle;
    msg->Handle = message_state->binding_handle;
    msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len;
    msg->BufferLength += message_state->prefix_data_len;
 
exit:
    HeapFree(GetProcessHeap(), 0, message_state);
    if (params->handle) SetEvent(params->handle);
}

Referenced by apartment_wndproc(), and dispatch_rpc().

RPC_GetLocalClassObject()

HRESULT RPC_GetLocalClassObject	(	REFCLSID	rclsid,
		REFIID	iid,
		LPVOID *	ppv
	)

Definition at line 1804 of file rpc.c.

{
    HRESULT        hres;
    HANDLE         hPipe;
    WCHAR          pipefn[100];
    DWORD          res, bufferlen;
    char           marshalbuffer[200];
    IStream       *pStm;
    LARGE_INTEGER  seekto;
    ULARGE_INTEGER newpos;
    int            tries = 0;
    IServiceProvider *local_server;
 
    static const int MAXTRIES = 30; /* 30 seconds */
 
    TRACE("rclsid=%s, iid=%s\n", debugstr_guid(rclsid), debugstr_guid(iid));
 
    get_localserver_pipe_name(pipefn, rclsid);
 
    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;
            HANDLE process = 0;
            if (tries == 1) {
                if ( (hres = create_local_service(rclsid)) &&
                     (hres = create_server(rclsid, &process)) )
                    return hres;
            } 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 */
            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 );
                    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)
        return E_NOINTERFACE;
    
    hres = CreateStreamOnHGlobal(0,TRUE,&pStm);
    if (hres != S_OK) return hres;
    hres = IStream_Write(pStm,marshalbuffer,bufferlen,&res);
    if (hres != S_OK) goto out;
    seekto.u.LowPart = 0;seekto.u.HighPart = 0;
    hres = IStream_Seek(pStm,seekto,STREAM_SEEK_SET,&newpos);
    
    TRACE("unmarshalling local server\n");
    hres = CoUnmarshalInterface(pStm, &IID_IServiceProvider, (void**)&local_server);
    if(SUCCEEDED(hres))
        hres = IServiceProvider_QueryService(local_server, rclsid, iid, ppv);
    IServiceProvider_Release(local_server);
out:
    IStream_Release(pStm);
    return hres;
}

Referenced by CoGetClassObject().

RPC_RegisterChannelHook()

HRESULT RPC_RegisterChannelHook	(	REFGUID	rguid,
		IChannelHook *	hook
	)

Definition at line 424 of file rpc.c.

{
    struct channel_hook_entry *entry;
 
    TRACE("(%s, %p)\n", debugstr_guid(rguid), hook);
 
    entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
    if (!entry)
        return E_OUTOFMEMORY;
 
    entry->id = *rguid;
    entry->hook = hook;
    IChannelHook_AddRef(hook);
 
    EnterCriticalSection(&csChannelHook);
    list_add_tail(&channel_hooks, &entry->entry);
    LeaveCriticalSection(&csChannelHook);
 
    return S_OK;
}

Referenced by CoRegisterChannelHook().

RPC_RegisterInterface()

HRESULT RPC_RegisterInterface

(

REFIID

riid

)

Definition at line 1530 of file rpc.c.

{
    struct registered_if *rif;
    BOOL found = FALSE;
    HRESULT hr = S_OK;
    
    TRACE("(%s)\n", debugstr_guid(riid));
 
    EnterCriticalSection(&csRegIf);
    LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry)
    {
        if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid))
        {
            rif->refs++;
            found = TRUE;
            break;
        }
    }
    if (!found)
    {
        TRACE("Creating new interface\n");
 
        rif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rif));
        if (rif)
        {
            RPC_STATUS status;
 
            rif->refs = 1;
            rif->If.Length = sizeof(RPC_SERVER_INTERFACE);
            /* RPC interface ID = COM interface ID */
            rif->If.InterfaceId.SyntaxGUID = *riid;
            rif->If.DispatchTable = &rpc_dispatch;
            /* all other fields are 0, including the version asCOM objects
             * always have a version of 0.0 */
            status = RpcServerRegisterIfEx(
                (RPC_IF_HANDLE)&rif->If,
                NULL, NULL,
                RPC_IF_OLE | RPC_IF_AUTOLISTEN,
                RPC_C_LISTEN_MAX_CALLS_DEFAULT,
                NULL);
            if (status == RPC_S_OK)
                list_add_tail(&registered_interfaces, &rif->entry);
            else
            {
                ERR("RpcServerRegisterIfEx failed with error %d\n", status);
                HeapFree(GetProcessHeap(), 0, rif);
                hr = HRESULT_FROM_WIN32(status);
            }
        }
        else
            hr = E_OUTOFMEMORY;
    }
    LeaveCriticalSection(&csRegIf);
    return hr;
}

Referenced by marshal_object().

RPC_ResolveOxid()

HRESULT RPC_ResolveOxid	(	OXID	oxid,
		OXID_INFO *	oxid_info
	)

Definition at line 1609 of file rpc.c.

{
    TRACE("%s\n", wine_dbgstr_longlong(oxid));
 
    oxid_info->dwTid = 0;
    oxid_info->dwPid = 0;
    oxid_info->dwAuthnHint = RPC_C_AUTHN_LEVEL_NONE;
    /* FIXME: this is a hack around not having an OXID resolver yet -
     * this function should contact the machine's OXID resolver and then it
     * should give us the IPID of the IRemUnknown interface */
    oxid_info->ipidRemUnknown.Data1 = 0xffffffff;
    oxid_info->ipidRemUnknown.Data2 = 0xffff;
    oxid_info->ipidRemUnknown.Data3 = 0xffff;
    memcpy(oxid_info->ipidRemUnknown.Data4, &oxid, sizeof(OXID));
    oxid_info->psa = NULL /* FIXME */;
 
    return S_OK;
}

Referenced by proxy_manager_construct().

RPC_StartLocalServer()

HRESULT RPC_StartLocalServer	(	REFCLSID	clsid,
		IStream *	stream,
		BOOL	multi_use,
		void **	registration
	)

Definition at line 1996 of file rpc.c.

{
    DWORD tid, err;
    struct local_server_params *lsp;
    WCHAR pipefn[100];
 
    lsp = HeapAlloc(GetProcessHeap(), 0, sizeof(*lsp));
    if (!lsp)
        return E_OUTOFMEMORY;
 
    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;
 
    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);
    }
 
    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;
}

Referenced by CoRegisterClassObject().

RPC_StartRemoting()

void RPC_StartRemoting

(

struct apartment *

apt

)

Definition at line 1630 of file rpc.c.

{
    if (!InterlockedExchange(&apt->remoting_started, TRUE))
    {
        WCHAR endpoint[200];
        RPC_STATUS status;
 
        get_rpc_endpoint(endpoint, &apt->oxid);
    
        status = RpcServerUseProtseqEpW(
            wszRpcTransport,
            RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
            endpoint,
            NULL);
        if (status != RPC_S_OK)
            ERR("Couldn't register endpoint %s\n", debugstr_w(endpoint));
 
        /* FIXME: move remote unknown exporting into this function */
    }
    start_apartment_remote_unknown(apt);
}

Referenced by StdMarshalImpl_MarshalInterface().

RPC_StopLocalServer()

void RPC_StopLocalServer

(

void *

registration

)

Definition at line 2044 of file rpc.c.

{
    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);
}

Referenced by COM_RevokeRegisteredClassObject().

RPC_UnregisterAllChannelHooks()

void RPC_UnregisterAllChannelHooks

(

void

)

Definition at line 445 of file rpc.c.

{
    struct channel_hook_entry *cursor;
    struct channel_hook_entry *cursor2;
 
    EnterCriticalSection(&csChannelHook);
    LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &channel_hooks, struct channel_hook_entry, entry)
        HeapFree(GetProcessHeap(), 0, cursor);
    LeaveCriticalSection(&csChannelHook);
    DeleteCriticalSection(&csChannelHook);
    DeleteCriticalSection(&csRegIf);
}

Referenced by DllMain().

RPC_UnregisterInterface()

void RPC_UnregisterInterface	(	REFIID	riid,
		BOOL	wait
	)

Definition at line 1587 of file rpc.c.

{
    struct registered_if *rif;
    EnterCriticalSection(&csRegIf);
    LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry)
    {
        if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid))
        {
            if (!--rif->refs)
            {
                RpcServerUnregisterIf((RPC_IF_HANDLE)&rif->If, NULL, wait);
                list_remove(&rif->entry);
                HeapFree(GetProcessHeap(), 0, rif);
            }
            break;
        }
    }
    LeaveCriticalSection(&csRegIf);
}

Referenced by stub_manager_delete_ifstub(), and stub_manager_disconnect().

RunningObjectTableImpl_Initialize()

HRESULT WINAPI RunningObjectTableImpl_Initialize

(

void

)

Definition at line 979 of file moniker.c.

{
    TRACE("\n");
 
    /* create the unique instance of the RunningObjectTableImpl structure */
    runningObjectTableInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(RunningObjectTableImpl));
 
    if (!runningObjectTableInstance)
        return E_OUTOFMEMORY;
 
    /* initialize the virtual table function */
    runningObjectTableInstance->IRunningObjectTable_iface.lpVtbl = &VT_RunningObjectTableImpl;
 
    /* the initial reference is set to "1" so that it isn't destroyed after its
     * first use until the process is destroyed, as the running object table is
     * a process-wide cache of a global table */
    runningObjectTableInstance->ref = 1;
 
    list_init(&runningObjectTableInstance->rot);
    InitializeCriticalSection(&runningObjectTableInstance->lock);
    DEBUG_SET_CRITSEC_NAME(&runningObjectTableInstance->lock, "RunningObjectTableImpl.lock");
 
    return S_OK;
}

Referenced by CoInitializeEx().

RunningObjectTableImpl_UnInitialize()

HRESULT WINAPI RunningObjectTableImpl_UnInitialize

(

void

)

Definition at line 1007 of file moniker.c.

{
    TRACE("\n");
 
    if (runningObjectTableInstance==NULL)
        return E_POINTER;
 
    RunningObjectTableImpl_Release(&runningObjectTableInstance->IRunningObjectTable_iface);
 
    RunningObjectTableImpl_Destroy();
 
    return S_OK;
}

Referenced by CoUninitialize().

start_apartment_remote_unknown()

HRESULT start_apartment_remote_unknown

(

APARTMENT *

apt

)

Definition at line 818 of file stubmanager.c.

{
    IRemUnknown *pRemUnknown;
    HRESULT hr = S_OK;
 
    EnterCriticalSection(&apt->cs);
    if (!apt->remunk_exported)
    {
        /* create the IRemUnknown object */
        hr = RemUnknown_Construct(&pRemUnknown);
        if (hr == S_OK)
        {
            STDOBJREF stdobjref; /* dummy - not used */
            /* register it with the stub manager */
            hr = marshal_object(apt, &stdobjref, &IID_IRemUnknown, (IUnknown *)pRemUnknown, MSHCTX_DIFFERENTMACHINE, NULL, MSHLFLAGS_NORMAL|MSHLFLAGSP_REMUNKNOWN);
            /* release our reference to the object as the stub manager will manage the life cycle for us */
            IRemUnknown_Release(pRemUnknown);
            if (hr == S_OK)
                apt->remunk_exported = TRUE;
        }
    }
    LeaveCriticalSection(&apt->cs);
    return hr;
}

Referenced by RPC_StartRemoting().

StdGlobalInterfaceTable_GetFactory()

HRESULT StdGlobalInterfaceTable_GetFactory

(

LPVOID *

ppv

)

Definition at line 344 of file git.c.

{
  *ppv = &git_classfactory;
  TRACE("Returning GIT classfactory\n");
  return S_OK;
}

Referenced by DllGetClassObject().

stub_manager_disconnect()

void stub_manager_disconnect

(

struct stub_manager *

m

)

Definition at line 244 of file stubmanager.c.

{
    struct ifstub *ifstub;
 
    EnterCriticalSection(&m->lock);
    if (!m->disconnected)
    {
        LIST_FOR_EACH_ENTRY(ifstub, &m->ifstubs, struct ifstub, entry)
            RPC_UnregisterInterface(&ifstub->iid, FALSE);
 
        m->disconnected = TRUE;
    }
    LeaveCriticalSection(&m->lock);
}

Referenced by CoDisconnectObject().

stub_manager_ext_addref()

ULONG stub_manager_ext_addref	(	struct stub_manager *	m,
		ULONG	refs,
		BOOL	tableweak
	)

Definition at line 408 of file stubmanager.c.

{
    BOOL first_extern_ref;
    ULONG rc;
 
    EnterCriticalSection(&m->lock);
 
    first_extern_ref = refs && !m->extrefs;
 
    /* make sure we don't overflow extrefs */
    refs = min(refs, (ULONG_MAX-1 - m->extrefs));
    rc = (m->extrefs += refs);
 
    if (tableweak)
        rc += ++m->weakrefs;
 
    LeaveCriticalSection(&m->lock);
    
    TRACE("added %u refs to %p (oid %s), rc is now %u\n", refs, m, wine_dbgstr_longlong(m->oid), rc);
 
    /*
     * NOTE: According to tests, creating a stub causes two AddConnection calls followed by
     * one ReleaseConnection call (with fLastReleaseCloses=FALSE).
     */
    if(first_extern_ref && m->extern_conn)
        IExternalConnection_AddConnection(m->extern_conn, EXTCONN_STRONG, 0);
 
    return rc;
}

Referenced by CoLockObjectExternal(), marshal_object(), and RemUnknown_RemAddRef().

stub_manager_ext_release()

ULONG stub_manager_ext_release	(	struct stub_manager *	m,
		ULONG	refs,
		BOOL	tableweak,
		BOOL	last_unlock_releases
	)

Definition at line 439 of file stubmanager.c.

{
    BOOL last_extern_ref;
    ULONG rc;
 
    EnterCriticalSection(&m->lock);
 
    /* make sure we don't underflow extrefs */
    refs = min(refs, m->extrefs);
    rc = (m->extrefs -= refs);
 
    if (tableweak)
        --m->weakrefs;
    if (!last_unlock_releases)
        rc += m->weakrefs;
 
    last_extern_ref = refs && !m->extrefs;
 
    LeaveCriticalSection(&m->lock);
    
    TRACE("removed %u refs from %p (oid %s), rc is now %u\n", refs, m, wine_dbgstr_longlong(m->oid), rc);
 
    if (last_extern_ref && m->extern_conn)
        IExternalConnection_ReleaseConnection(m->extern_conn, EXTCONN_STRONG, 0, last_unlock_releases);
 
    if (rc == 0)
        if (!(m->extern_conn && last_unlock_releases && m->weakrefs))
            stub_manager_int_release(m);
 
    return rc;
}

Referenced by CoLockObjectExternal(), marshal_object(), RemUnknown_RemRelease(), std_unmarshal_interface(), and stub_manager_release_marshal_data().

stub_manager_find_ifstub()

struct ifstub * stub_manager_find_ifstub	(	struct stub_manager *	m,
		REFIID	iid,
		MSHLFLAGS	flags
	)

Definition at line 158 of file stubmanager.c.

{
    struct ifstub  *result = NULL;
    struct ifstub  *ifstub;
 
    EnterCriticalSection(&m->lock);
    LIST_FOR_EACH_ENTRY( ifstub, &m->ifstubs, struct ifstub, entry )
    {
        if (IsEqualIID(iid, &ifstub->iid) && (ifstub->flags == flags))
        {
            result = ifstub;
            break;
        }
    }
    LeaveCriticalSection(&m->lock);
 
    return result;
}

Referenced by marshal_object().

stub_manager_int_release()

ULONG stub_manager_int_release

(

struct stub_manager *

This

)

Definition at line 311 of file stubmanager.c.

{
    ULONG refs;
    APARTMENT *apt = This->apt;
 
    EnterCriticalSection(&apt->cs);
    refs = --This->refs;
 
    TRACE("after %d\n", refs);
 
    /* remove from apartment so no other thread can access it... */
    if (!refs)
        list_remove(&This->entry);
 
    LeaveCriticalSection(&apt->cs);
 
    /* ... so now we can delete it without being inside the apartment critsec */
    if (!refs)
        stub_manager_delete(This);
 
    return refs;
}

Referenced by apartment_release(), CoDisconnectObject(), CoLockObjectExternal(), dispatch_rpc(), ipid_get_dispatch_params(), marshal_object(), RemUnknown_RemAddRef(), RemUnknown_RemQueryInterface(), RemUnknown_RemRelease(), std_release_marshal_data(), std_unmarshal_interface(), and stub_manager_ext_release().

stub_manager_is_table_marshaled()

BOOL stub_manager_is_table_marshaled	(	struct stub_manager *	m,
		const IPID *	ipid
	)

Definition at line 609 of file stubmanager.c.

{
    struct ifstub *ifstub = stub_manager_ipid_to_ifstub(m, ipid);
 
    assert( ifstub );
    
    return ifstub->flags & (MSHLFLAGS_TABLESTRONG | MSHLFLAGS_TABLEWEAK);
}

Referenced by std_unmarshal_interface().

stub_manager_new_ifstub()

struct ifstub * stub_manager_new_ifstub	(	struct stub_manager *	m,
		IRpcStubBuffer *	sb,
		REFIID	iid,
		DWORD	dest_context,
		void *	dest_context_data,
		MSHLFLAGS	flags
	)

Definition at line 70 of file stubmanager.c.

{
    struct ifstub *stub;
    HRESULT hr;
 
    TRACE("oid=%s, stubbuffer=%p, iid=%s, dest_context=%x\n", wine_dbgstr_longlong(m->oid), sb,
          debugstr_guid(iid), dest_context);
 
    stub = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct ifstub));
    if (!stub) return NULL;
 
    hr = IUnknown_QueryInterface(m->object, iid, (void **)&stub->iface);
    if (hr != S_OK)
    {
        HeapFree(GetProcessHeap(), 0, stub);
        return NULL;
    }
 
    hr = RPC_CreateServerChannel(dest_context, dest_context_data, &stub->chan);
    if (hr != S_OK)
    {
        IUnknown_Release(stub->iface);
        HeapFree(GetProcessHeap(), 0, stub);
        return NULL;
    }
 
    stub->stubbuffer = sb;
    if (sb) IRpcStubBuffer_AddRef(sb);
 
    stub->flags = flags;
    stub->iid = *iid;
 
    /* FIXME: find a cleaner way of identifying that we are creating an ifstub
     * for the remunknown interface */
    if (flags & MSHLFLAGSP_REMUNKNOWN)
        stub->ipid = m->oxid_info.ipidRemUnknown;
    else
        generate_ipid(m, &stub->ipid);
 
    EnterCriticalSection(&m->lock);
    list_add_head(&m->ifstubs, &stub->entry);
    /* every normal marshal is counted so we don't allow more than we should */
    if (flags & MSHLFLAGS_NORMAL) m->norm_refs++;
    LeaveCriticalSection(&m->lock);
 
    TRACE("ifstub %p created with ipid %s\n", stub, debugstr_guid(&stub->ipid));
 
    return stub;
}

Referenced by marshal_object().

stub_manager_notify_unmarshal()

BOOL stub_manager_notify_unmarshal	(	struct stub_manager *	m,
		const IPID *	ipid
	)

Definition at line 562 of file stubmanager.c.

{
    BOOL ret = TRUE;
    struct ifstub *ifstub;
 
    if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
    {
        ERR("attempted unmarshal of unknown IPID %s\n", debugstr_guid(ipid));
        return FALSE;
    }
 
    EnterCriticalSection(&m->lock);
 
    /* track normal marshals so we can enforce rules whilst in-process */
    if (ifstub->flags & MSHLFLAGS_NORMAL)
    {
        if (m->norm_refs)
            m->norm_refs--;
        else
        {
            ERR("attempted invalid normal unmarshal, norm_refs is zero\n");
            ret = FALSE;
        }
    }
 
    LeaveCriticalSection(&m->lock);
 
    return ret;
}

Referenced by std_unmarshal_interface().

stub_manager_release_marshal_data()

void stub_manager_release_marshal_data	(	struct stub_manager *	m,
		ULONG	refs,
		const IPID *	ipid,
		BOOL	tableweak
	)

Definition at line 593 of file stubmanager.c.

{
    struct ifstub *ifstub;
 
    if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
        return;
 
    if (ifstub->flags & MSHLFLAGS_TABLEWEAK)
        refs = 0;
    else if (ifstub->flags & MSHLFLAGS_TABLESTRONG)
        refs = 1;
 
    stub_manager_ext_release(m, refs, tableweak, !tableweak);
}

Referenced by std_release_marshal_data().

Variable Documentation

DECLSPEC_HIDDEN

UINT ole_private_data_clipboard_format DECLSPEC_HIDDEN

extern

Definition at line 318 of file compobj_private.h.