ReactOS 0.4.15-dev-8348-gc1b9bb5
git.c
Go to the documentation of this file.
1/*
2 * Implementation of the StdGlobalInterfaceTable object
3 *
4 * The GlobalInterfaceTable (GIT) object is used to marshal interfaces between
5 * threading apartments (contexts). When you want to pass an interface but not
6 * as a parameter, it wouldn't get marshalled automatically, so you can use this
7 * object to insert the interface into a table, and you get back a cookie.
8 * Then when it's retrieved, it'll be unmarshalled into the right apartment.
9 *
10 * Copyright 2003 Mike Hearn <mike@theoretic.com>
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27#include <stdarg.h>
28
29#define COBJMACROS
30
31#include "windef.h"
32#include "winbase.h"
33#include "winuser.h"
34#include "objbase.h"
35#include "ole2.h"
36#include "winerror.h"
37
38#include "compobj_private.h"
39
40#include "wine/list.h"
41#include "wine/debug.h"
42
44
45/****************************************************************************
46 * StdGlobalInterfaceTable definition
47 *
48 * This class implements IGlobalInterfaceTable and is a process-wide singleton
49 * used for marshalling interfaces between threading apartments using cookies.
50 */
51
52/* Each entry in the linked list of GIT entries */
53typedef struct StdGITEntry
54{
56 IID iid; /* IID of the interface */
57 IStream* stream; /* Holds the marshalled interface */
58
59 struct list entry;
61
62/* Class data */
64{
66
67 struct list list;
69
71
73
76{
77 0, 0, &git_section,
79 0, 0, { (DWORD_PTR)(__FILE__ ": global interface table") }
80};
81static CRITICAL_SECTION git_section = { &critsect_debug, -1, 0, 0, 0, 0 };
82
83
85{
86 return CONTAINING_RECORD(iface, StdGlobalInterfaceTableImpl, IGlobalInterfaceTable_iface);
87}
88
89/***
90 * A helper function to traverse the list and find the entry that matches the cookie.
91 * Returns NULL if not found. Must be called inside git_section critical section.
92 */
95{
97
98 TRACE("This=%p, cookie=0x%x\n", This, cookie);
99
101 if (e->cookie == cookie)
102 return e;
103 }
104
105 TRACE("Entry not found\n");
106 return NULL;
107}
108
109/***
110 * Here's the boring boilerplate stuff for IUnknown
111 */
112
113static HRESULT WINAPI
115 REFIID riid, void** ppvObject)
116{
117 /* Make sure silly coders can't crash us */
118 if (ppvObject == 0) return E_INVALIDARG;
119
120 *ppvObject = 0; /* assume we don't have the interface */
121
122 /* Do we implement that interface? */
124 IsEqualIID(&IID_IGlobalInterfaceTable, riid))
125 {
126 *ppvObject = iface;
127 }
128 else
129 {
130 FIXME("(%s), not supported.\n", debugstr_guid(riid));
131 return E_NOINTERFACE;
132 }
133
134 /* Now inc the refcount */
135 IGlobalInterfaceTable_AddRef(iface);
136 return S_OK;
137}
138
139static ULONG WINAPI
141{
142 return 1;
143}
144
145static ULONG WINAPI
147{
148 return 1;
149}
150
151/***
152 * Now implement the actual IGlobalInterfaceTable interface
153 */
154
155static HRESULT WINAPI
158 REFIID riid, DWORD* pdwCookie)
159{
165
166 TRACE("iface=%p, pUnk=%p, riid=%s, pdwCookie=0x%p\n", iface, pUnk, debugstr_guid(riid), pdwCookie);
167
168 if (pUnk == NULL) return E_INVALIDARG;
169
170 /* marshal the interface */
171 TRACE("About to marshal the interface\n");
172
174 if (hres != S_OK) return hres;
175 hres = CoMarshalInterface(stream, riid, pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLESTRONG);
176 if (hres != S_OK)
177 {
178 IStream_Release(stream);
179 return hres;
180 }
181
182 zero.QuadPart = 0;
183 IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
184
185 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(StdGITEntry));
186 if (!entry)
187 {
189 IStream_Release(stream);
190 return E_OUTOFMEMORY;
191 }
192
194
195 entry->iid = *riid;
196 entry->stream = stream;
197 entry->cookie = This->nextCookie;
198 This->nextCookie++; /* inc the cookie count */
199
200 /* insert the new entry at the end of the list */
201 list_add_tail(&This->list, &entry->entry);
202
203 /* and return the cookie */
204 *pdwCookie = entry->cookie;
205
207
208 TRACE("Cookie is 0x%x\n", entry->cookie);
209 return S_OK;
210}
211
212static HRESULT WINAPI
214 IGlobalInterfaceTable* iface, DWORD dwCookie)
215{
218 HRESULT hr;
219
220 TRACE("iface=%p, dwCookie=0x%x\n", iface, dwCookie);
221
223
225 if (entry == NULL) {
226 TRACE("Entry not found\n");
228 return E_INVALIDARG; /* not found */
229 }
230
231 list_remove(&entry->entry);
232
234
235 /* Free the stream */
236 hr = CoReleaseMarshalData(entry->stream);
237 if (hr != S_OK)
238 {
239 WARN("Failed to release marshal data, hr = 0x%08x\n", hr);
240 return hr;
241 }
242 IStream_Release(entry->stream);
243
245 return S_OK;
246}
247
248static HRESULT WINAPI
250 IGlobalInterfaceTable* iface, DWORD dwCookie,
251 REFIID riid, void **ppv)
252{
257
258 TRACE("dwCookie=0x%x, riid=%s, ppv=%p\n", dwCookie, debugstr_guid(riid), ppv);
259
261
263 if (entry == NULL) {
264 WARN("Entry for cookie 0x%x not found\n", dwCookie);
266 return E_INVALIDARG;
267 }
268
269 TRACE("entry=%p\n", entry);
270
271 hres = IStream_Clone(entry->stream, &stream);
272
274
275 if (hres != S_OK) {
276 WARN("Failed to clone stream with error 0x%08x\n", hres);
277 return hres;
278 }
279
280 /* unmarshal the interface */
282 IStream_Release(stream);
283
284 if (hres != S_OK) {
285 WARN("Failed to unmarshal stream\n");
286 return hres;
287 }
288
289 TRACE("ppv=%p\n", *ppv);
290 return S_OK;
291}
292
293/* Classfactory definition - despite what MSDN says, some programs need this */
294
295static HRESULT WINAPI
297{
298 *ppv = NULL;
301 {
302 *ppv = iface;
303 return S_OK;
304 }
305 return E_NOINTERFACE;
306}
307
308static ULONG WINAPI GITCF_AddRef(LPCLASSFACTORY iface)
309{
310 return 2;
311}
312
313static ULONG WINAPI GITCF_Release(LPCLASSFACTORY iface)
314{
315 return 1;
316}
317
318static HRESULT WINAPI
319GITCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pUnk,
321{
323 HRESULT hr = IGlobalInterfaceTable_QueryInterface(git, riid, ppv);
324 IGlobalInterfaceTable_Release(git);
325 return hr;
326}
327
328static HRESULT WINAPI GITCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
329{
330 FIXME("(%d), stub!\n",fLock);
331 return S_OK;
332}
333
334static const IClassFactoryVtbl GITClassFactoryVtbl = {
340};
341
343
345{
347 TRACE("Returning GIT classfactory\n");
348 return S_OK;
349}
350
351/* Virtual function table */
352static const IGlobalInterfaceTableVtbl StdGlobalInterfaceTableImpl_Vtbl =
353{
360};
361
363{
364 if (!std_git)
365 {
367
369 if (!newGIT) return NULL;
370
372 list_init(&newGIT->list);
373 newGIT->nextCookie = 0xf100; /* that's where windows starts, so that's where we start */
374
376 {
377 HeapFree(GetProcessHeap(), 0, newGIT);
378 }
379 else
380 TRACE("Created the GIT at %p\n", newGIT);
381 }
382
383 return std_git;
384}
385
387{
389 StdGITEntry *entry, *entry2;
390
391 if (!std_git) return;
392
395 {
396 list_remove(&entry->entry);
397
399 IStream_Release(entry->stream);
401 }
402
403 HeapFree(GetProcessHeap(), 0, git);
404}
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
static void list_init(struct list_entry *head)
Definition: list.h:51
#define FIXME(fmt,...)
Definition: precomp.h:53
#define WARN(fmt,...)
Definition: precomp.h:61
const GUID IID_IUnknown
const GUID IID_IClassFactory
Definition: list.h:37
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
HRESULT WINAPI CoReleaseMarshalData(IStream *pStream)
Definition: marshal.c:2055
HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
Definition: marshal.c:1981
HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk, DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags)
Definition: marshal.c:1876
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
static HRESULT WINAPI StdGlobalInterfaceTable_RevokeInterfaceFromGlobal(IGlobalInterfaceTable *iface, DWORD dwCookie)
Definition: git.c:213
static IGlobalInterfaceTable * std_git
Definition: git.c:72
static HRESULT WINAPI GITCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
Definition: git.c:319
static StdGlobalInterfaceTableImpl * impl_from_IGlobalInterfaceTable(IGlobalInterfaceTable *iface)
Definition: git.c:84
void release_std_git(void)
Definition: git.c:386
static const IClassFactoryVtbl GITClassFactoryVtbl
Definition: git.c:334
HRESULT StdGlobalInterfaceTable_GetFactory(LPVOID *ppv)
Definition: git.c:344
static CRITICAL_SECTION_DEBUG critsect_debug
Definition: git.c:75
static StdGITEntry * StdGlobalInterfaceTable_FindEntry(StdGlobalInterfaceTableImpl *This, DWORD cookie)
Definition: git.c:93
static CRITICAL_SECTION git_section
Definition: git.c:74
static ULONG WINAPI GITCF_AddRef(LPCLASSFACTORY iface)
Definition: git.c:308
static HRESULT WINAPI StdGlobalInterfaceTable_QueryInterface(IGlobalInterfaceTable *iface, REFIID riid, void **ppvObject)
Definition: git.c:114
static const IGlobalInterfaceTableVtbl StdGlobalInterfaceTableImpl_Vtbl
Definition: git.c:352
static HRESULT WINAPI GITCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
Definition: git.c:328
static HRESULT WINAPI StdGlobalInterfaceTable_RegisterInterfaceInGlobal(IGlobalInterfaceTable *iface, IUnknown *pUnk, REFIID riid, DWORD *pdwCookie)
Definition: git.c:156
IGlobalInterfaceTable * get_std_git(void)
Definition: git.c:362
static IClassFactory git_classfactory
Definition: git.c:342
static ULONG WINAPI StdGlobalInterfaceTable_Release(IGlobalInterfaceTable *iface)
Definition: git.c:146
static ULONG WINAPI StdGlobalInterfaceTable_AddRef(IGlobalInterfaceTable *iface)
Definition: git.c:140
static HRESULT WINAPI GITCF_QueryInterface(LPCLASSFACTORY iface, REFIID riid, LPVOID *ppv)
Definition: git.c:296
static ULONG WINAPI GITCF_Release(LPCLASSFACTORY iface)
Definition: git.c:313
static HRESULT WINAPI StdGlobalInterfaceTable_GetInterfaceFromGlobal(IGlobalInterfaceTable *iface, DWORD dwCookie, REFIID riid, void **ppv)
Definition: git.c:249
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
#define S_OK
Definition: intsafe.h:52
uint32_t entry
Definition: isohybrid.c:63
#define e
Definition: ke_i.h:82
#define debugstr_guid
Definition: kernel32.h:35
HRESULT hres
Definition: protocol.c:465
static LPUNKNOWN
Definition: ndr_ole.c:49
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
int zero
Definition: sehframes.cpp:29
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
DWORD cookie
Definition: git.c:55
IStream * stream
Definition: git.c:57
struct list entry
Definition: git.c:59
IID iid
Definition: git.c:56
struct list list
Definition: git.c:67
IGlobalInterfaceTable IGlobalInterfaceTable_iface
Definition: git.c:65
LIST_ENTRY ProcessLocksList
Definition: winbase.h:883
Definition: cookie.c:34
Definition: parse.h:23
#define DWORD_PTR
Definition: treelist.c:76
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
#define WINAPI
Definition: msvc.h:6
#define E_NOINTERFACE
Definition: winerror.h:2364