projects / reactos.git / blob
? search:


9de947caf4b72dbe1d17f367c684ee82c97fafae
[reactos.git] / reactos / dll / win32 / ole32 / moniker.c
1 /*
2 * Monikers
3 *
4 * Copyright 1998 Marcus Meissner
5 * Copyright 1999 Noomen Hamza
6 * Copyright 2005 Robert Shearman (for CodeWeavers)
7 * Copyright 2007 Robert Shearman
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #define WIN32_NO_STATUS
25 #define _INC_WINDOWS
26
27 #include <config.h>
28 //#include "wine/port.h"
29
30 #include <stdarg.h>
31 //#include <string.h>
32
33 #define COBJMACROS
34
35 //#include "winerror.h"
36 #include <windef.h>
37 #include <winbase.h>
38 //#include "winuser.h"
39 //#include "wtypes.h"
40 #include <ole2.h>
41
42 //#include "wine/list.h"
43 #include <wine/debug.h>
44 #include <wine/unicode.h>
45 #include <wine/exception.h>
46
47 #include "compobj_private.h"
48 #include "moniker.h"
49 #include <irot.h>
50
51 WINE_DEFAULT_DEBUG_CHANNEL(ole);
52
53 /* see MSDN docs for IROTData::GetComparisonData, which states what this
54 * constant is
55 */
56 #define MAX_COMPARISON_DATA 2048
57
58 static LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr)
59 {
60 return I_RpcExceptionFilter(eptr->ExceptionRecord->ExceptionCode);
61 }
62
63 /* define the structure of the running object table elements */
64 struct rot_entry
65 {
66 struct list entry;
67 InterfaceData* object; /* marshaled running object*/
68 MonikerComparisonData* moniker_data; /* moniker comparison data that identifies this object */
69 DWORD cookie; /* cookie identifying this object */
70 FILETIME last_modified;
71 IrotContextHandle ctxt_handle;
72 };
73
74 /* define the RunningObjectTableImpl structure */
75 typedef struct RunningObjectTableImpl
76 {
77 IRunningObjectTable IRunningObjectTable_iface;
78 LONG ref;
79
80 struct list rot; /* list of ROT entries */
81 CRITICAL_SECTION lock;
82 } RunningObjectTableImpl;
83
84 static RunningObjectTableImpl* runningObjectTableInstance = NULL;
85 static IrotHandle irot_handle;
86
87 /* define the EnumMonikerImpl structure */
88 typedef struct EnumMonikerImpl
89 {
90 IEnumMoniker IEnumMoniker_iface;
91 LONG ref;
92
93 InterfaceList *moniker_list;
94 ULONG pos;
95 } EnumMonikerImpl;
96
97 static inline RunningObjectTableImpl *impl_from_IRunningObjectTable(IRunningObjectTable *iface)
98 {
99 return CONTAINING_RECORD(iface, RunningObjectTableImpl, IRunningObjectTable_iface);
100 }
101
102 static inline EnumMonikerImpl *impl_from_IEnumMoniker(IEnumMoniker *iface)
103 {
104 return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
105 }
106
107 /* IEnumMoniker Local functions*/
108 static HRESULT EnumMonikerImpl_CreateEnumROTMoniker(InterfaceList *moniker_list,
109 ULONG pos, IEnumMoniker **ppenumMoniker);
110
111 static IrotHandle get_irot_handle(void)
112 {
113 if (!irot_handle)
114 {
115 RPC_STATUS status;
116 RPC_WSTR binding;
117 IrotHandle new_handle;
118 unsigned short ncacn_np[] = IROT_PROTSEQ;
119 unsigned short endpoint[] = IROT_ENDPOINT;
120 status = RpcStringBindingComposeW(NULL, ncacn_np, NULL, endpoint, NULL, &binding);
121 if (status == RPC_S_OK)
122 {
123 status = RpcBindingFromStringBindingW(binding, &new_handle);
124 RpcStringFreeW(&binding);
125 }
126 if (status != RPC_S_OK)
127 return NULL;
128 if (InterlockedCompareExchangePointer(&irot_handle, new_handle, NULL))
129 /* another thread beat us to it */
130 RpcBindingFree(&new_handle);
131 }
132 return irot_handle;
133 }
134
135 static BOOL start_rpcss(void)
136 {
137 PROCESS_INFORMATION pi;
138 STARTUPINFOW si;
139 WCHAR cmd[MAX_PATH];
140 static const WCHAR rpcss[] = {'\\','r','p','c','s','s','.','e','x','e',0};
141 BOOL rslt;
142 void *redir;
143
144 TRACE("\n");
145
146 ZeroMemory(&si, sizeof(STARTUPINFOA));
147 si.cb = sizeof(STARTUPINFOA);
148 GetSystemDirectoryW( cmd, MAX_PATH - sizeof(rpcss)/sizeof(WCHAR) );
149 strcatW( cmd, rpcss );
150
151 Wow64DisableWow64FsRedirection( &redir );
152 rslt = CreateProcessW( cmd, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &si, &pi );
153 Wow64RevertWow64FsRedirection( redir );
154
155 if (rslt)
156 {
157 CloseHandle(pi.hProcess);
158 CloseHandle(pi.hThread);
159 Sleep(100);
160 }
161
162 return rslt;
163 }
164
165 static HRESULT create_stream_on_mip_ro(const InterfaceData *mip, IStream **stream)
166 {
167 HGLOBAL hglobal = GlobalAlloc(0, mip->ulCntData);
168 void *pv = GlobalLock(hglobal);
169 memcpy(pv, mip->abData, mip->ulCntData);
170 GlobalUnlock(hglobal);
171 return CreateStreamOnHGlobal(hglobal, TRUE, stream);
172 }
173
174 static void rot_entry_delete(struct rot_entry *rot_entry)
175 {
176 if (rot_entry->cookie)
177 {
178 InterfaceData *object = NULL;
179 InterfaceData *moniker = NULL;
180 __TRY
181 {
182 IrotRevoke(get_irot_handle(), rot_entry->cookie,
183 &rot_entry->ctxt_handle, &object, &moniker);
184 }
185 __EXCEPT(rpc_filter)
186 {
187 }
188 __ENDTRY
189 MIDL_user_free(object);
190 if (moniker)
191 {
192 IStream *stream;
193 HRESULT hr;
194 hr = create_stream_on_mip_ro(moniker, &stream);
195 if (hr == S_OK)
196 {
197 CoReleaseMarshalData(stream);
198 IStream_Release(stream);
199 }
200 }
201 MIDL_user_free(moniker);
202 }
203 if (rot_entry->object)
204 {
205 IStream *stream;
206 HRESULT hr;
207 hr = create_stream_on_mip_ro(rot_entry->object, &stream);
208 if (hr == S_OK)
209 {
210 CoReleaseMarshalData(stream);
211 IStream_Release(stream);
212 }
213 }
214 HeapFree(GetProcessHeap(), 0, rot_entry->object);
215 HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data);
216 HeapFree(GetProcessHeap(), 0, rot_entry);
217 }
218
219 /* moniker_data must be freed with HeapFree when no longer in use */
220 static HRESULT get_moniker_comparison_data(IMoniker *pMoniker, MonikerComparisonData **moniker_data)
221 {
222 HRESULT hr;
223 IROTData *pROTData = NULL;
224 hr = IMoniker_QueryInterface(pMoniker, &IID_IROTData, (void *)&pROTData);
225 if (SUCCEEDED(hr))
226 {
227 ULONG size = MAX_COMPARISON_DATA;
228 *moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MonikerComparisonData, abData[size]));
229 if (!*moniker_data)
230 {
231 IROTData_Release(pROTData);
232 return E_OUTOFMEMORY;
233 }
234 hr = IROTData_GetComparisonData(pROTData, (*moniker_data)->abData, size, &size);
235 IROTData_Release(pROTData);
236 if (hr != S_OK)
237 {
238 ERR("Failed to copy comparison data into buffer, hr = 0x%08x\n", hr);
239 HeapFree(GetProcessHeap(), 0, *moniker_data);
240 return hr;
241 }
242 (*moniker_data)->ulCntData = size;
243 }
244 else
245 {
246 IBindCtx *pbc;
247 LPOLESTR pszDisplayName;
248 CLSID clsid;
249 int len;
250
251 TRACE("generating comparison data from display name\n");
252
253 hr = CreateBindCtx(0, &pbc);
254 if (FAILED(hr))
255 return hr;
256 hr = IMoniker_GetDisplayName(pMoniker, pbc, NULL, &pszDisplayName);
257 IBindCtx_Release(pbc);
258 if (FAILED(hr))
259 return hr;
260 hr = IMoniker_GetClassID(pMoniker, &clsid);
261 if (FAILED(hr))
262 {
263 CoTaskMemFree(pszDisplayName);
264 return hr;
265 }
266
267 len = strlenW(pszDisplayName);
268 *moniker_data = HeapAlloc(GetProcessHeap(), 0,
269 FIELD_OFFSET(MonikerComparisonData, abData[sizeof(CLSID) + (len+1)*sizeof(WCHAR)]));
270 if (!*moniker_data)
271 {
272 CoTaskMemFree(pszDisplayName);
273 return E_OUTOFMEMORY;
274 }
275 (*moniker_data)->ulCntData = sizeof(CLSID) + (len+1)*sizeof(WCHAR);
276
277 memcpy(&(*moniker_data)->abData[0], &clsid, sizeof(clsid));
278 memcpy(&(*moniker_data)->abData[sizeof(clsid)], pszDisplayName, (len+1)*sizeof(WCHAR));
279 CoTaskMemFree(pszDisplayName);
280 }
281 return S_OK;
282 }
283
284 static HRESULT reduce_moniker(IMoniker *pmk, IBindCtx *pbc, IMoniker **pmkReduced)
285 {
286 IBindCtx *pbcNew = NULL;
287 HRESULT hr;
288 if (!pbc)
289 {
290 hr = CreateBindCtx(0, &pbcNew);
291 if (FAILED(hr))
292 return hr;
293 pbc = pbcNew;
294 }
295 hr = IMoniker_Reduce(pmk, pbc, MKRREDUCE_ALL, NULL, pmkReduced);
296 if (FAILED(hr))
297 ERR("reducing moniker failed with error 0x%08x\n", hr);
298 if (pbcNew) IBindCtx_Release(pbcNew);
299 return hr;
300 }
301
302 /***********************************************************************
303 * RunningObjectTable_QueryInterface
304 */
305 static HRESULT WINAPI
306 RunningObjectTableImpl_QueryInterface(IRunningObjectTable* iface,
307 REFIID riid,void** ppvObject)
308 {
309 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
310
311 TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
312
313 /* validate arguments */
314
315 if (ppvObject==0)
316 return E_INVALIDARG;
317
318 *ppvObject = 0;
319
320 if (IsEqualIID(&IID_IUnknown, riid) ||
321 IsEqualIID(&IID_IRunningObjectTable, riid))
322 *ppvObject = This;
323
324 if ((*ppvObject)==0)
325 return E_NOINTERFACE;
326
327 IRunningObjectTable_AddRef(iface);
328
329 return S_OK;
330 }
331
332 /***********************************************************************
333 * RunningObjectTable_AddRef
334 */
335 static ULONG WINAPI
336 RunningObjectTableImpl_AddRef(IRunningObjectTable* iface)
337 {
338 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
339
340 TRACE("(%p)\n",This);
341
342 return InterlockedIncrement(&This->ref);
343 }
344
345 /***********************************************************************
346 * RunningObjectTable_Destroy
347 */
348 static HRESULT
349 RunningObjectTableImpl_Destroy(void)
350 {
351 struct list *cursor, *cursor2;
352 IrotHandle old_handle;
353
354 TRACE("()\n");
355
356 if (runningObjectTableInstance==NULL)
357 return E_INVALIDARG;
358
359 /* free the ROT table memory */
360 LIST_FOR_EACH_SAFE(cursor, cursor2, &runningObjectTableInstance->rot)
361 {
362 struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
363 list_remove(&rot_entry->entry);
364 rot_entry_delete(rot_entry);
365 }
366
367 DEBUG_CLEAR_CRITSEC_NAME(&runningObjectTableInstance->lock);
368 DeleteCriticalSection(&runningObjectTableInstance->lock);
369
370 /* free the ROT structure memory */
371 HeapFree(GetProcessHeap(),0,runningObjectTableInstance);
372 runningObjectTableInstance = NULL;
373
374 old_handle = irot_handle;
375 irot_handle = NULL;
376 if (old_handle)
377 RpcBindingFree(&old_handle);
378
379 return S_OK;
380 }
381
382 /***********************************************************************
383 * RunningObjectTable_Release
384 */
385 static ULONG WINAPI
386 RunningObjectTableImpl_Release(IRunningObjectTable* iface)
387 {
388 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
389 ULONG ref;
390
391 TRACE("(%p)\n",This);
392
393 ref = InterlockedDecrement(&This->ref);
394
395 /* uninitialize ROT structure if there's no more references to it */
396 if (ref == 0)
397 {
398 struct list *cursor, *cursor2;
399 LIST_FOR_EACH_SAFE(cursor, cursor2, &This->rot)
400 {
401 struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
402 list_remove(&rot_entry->entry);
403 rot_entry_delete(rot_entry);
404 }
405 /* RunningObjectTable data structure will be not destroyed here ! the destruction will be done only
406 * when RunningObjectTableImpl_UnInitialize function is called
407 */
408 }
409
410 return ref;
411 }
412
413 /***********************************************************************
414 * RunningObjectTable_Register
415 *
416 * PARAMS
417 * grfFlags [in] Registration options
418 * punkObject [in] the object being registered
419 * pmkObjectName [in] the moniker of the object being registered
420 * pdwRegister [out] the value identifying the registration
421 */
422 static HRESULT WINAPI
423 RunningObjectTableImpl_Register(IRunningObjectTable* iface, DWORD grfFlags,
424 IUnknown *punkObject, IMoniker *pmkObjectName, DWORD *pdwRegister)
425 {
426 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
427 struct rot_entry *rot_entry;
428 HRESULT hr = S_OK;
429 IStream *pStream = NULL;
430 DWORD mshlflags;
431 IBindCtx *pbc;
432 InterfaceData *moniker = NULL;
433
434 TRACE("(%p,%d,%p,%p,%p)\n",This,grfFlags,punkObject,pmkObjectName,pdwRegister);
435
436 if (grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT))
437 {
438 ERR("Invalid grfFlags: 0x%08x\n", grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT));
439 return E_INVALIDARG;
440 }
441
442 if (punkObject==NULL || pmkObjectName==NULL || pdwRegister==NULL)
443 return E_INVALIDARG;
444
445 rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry));
446 if (!rot_entry)
447 return E_OUTOFMEMORY;
448
449 /* marshal object */
450 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
451 if (hr != S_OK)
452 {
453 rot_entry_delete(rot_entry);
454 return hr;
455 }
456 mshlflags = (grfFlags & ROTFLAGS_REGISTRATIONKEEPSALIVE) ? MSHLFLAGS_TABLESTRONG : MSHLFLAGS_TABLEWEAK;
457 hr = CoMarshalInterface(pStream, &IID_IUnknown, punkObject, MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, mshlflags);
458 /* FIXME: a cleaner way would be to create an IStream class that writes
459 * directly to an MInterfacePointer */
460 if (hr == S_OK)
461 {
462 HGLOBAL hglobal;
463 hr = GetHGlobalFromStream(pStream, &hglobal);
464 if (hr == S_OK)
465 {
466 SIZE_T size = GlobalSize(hglobal);
467 const void *pv = GlobalLock(hglobal);
468 rot_entry->object = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MInterfacePointer, abData[size]));
469 rot_entry->object->ulCntData = size;
470 memcpy(rot_entry->object->abData, pv, size);
471 GlobalUnlock(hglobal);
472 }
473 }
474 IStream_Release(pStream);
475 if (hr != S_OK)
476 {
477 rot_entry_delete(rot_entry);
478 return hr;
479 }
480
481 hr = CreateBindCtx(0, &pbc);
482 if (FAILED(hr))
483 {
484 rot_entry_delete(rot_entry);
485 return hr;
486 }
487
488 hr = reduce_moniker(pmkObjectName, pbc, &pmkObjectName);
489 if (FAILED(hr))
490 {
491 rot_entry_delete(rot_entry);
492 IBindCtx_Release(pbc);
493 return hr;
494 }
495
496 hr = IMoniker_GetTimeOfLastChange(pmkObjectName, pbc, NULL,
497 &rot_entry->last_modified);
498 IBindCtx_Release(pbc);
499 if (FAILED(hr))
500 {
501 CoFileTimeNow(&rot_entry->last_modified);
502 hr = S_OK;
503 }
504
505 hr = get_moniker_comparison_data(pmkObjectName,
506 &rot_entry->moniker_data);
507 if (hr != S_OK)
508 {
509 rot_entry_delete(rot_entry);
510 IMoniker_Release(pmkObjectName);
511 return hr;
512 }
513
514 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
515 if (hr != S_OK)
516 {
517 rot_entry_delete(rot_entry);
518 IMoniker_Release(pmkObjectName);
519 return hr;
520 }
521 /* marshal moniker */
522 hr = CoMarshalInterface(pStream, &IID_IMoniker, (IUnknown *)pmkObjectName,
523 MSHCTX_LOCAL | MSHCTX_NOSHAREDMEM, NULL, MSHLFLAGS_TABLESTRONG);
524 /* FIXME: a cleaner way would be to create an IStream class that writes
525 * directly to an MInterfacePointer */
526 if (hr == S_OK)
527 {
528 HGLOBAL hglobal;
529 hr = GetHGlobalFromStream(pStream, &hglobal);
530 if (hr == S_OK)
531 {
532 SIZE_T size = GlobalSize(hglobal);
533 const void *pv = GlobalLock(hglobal);
534 moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[size]));
535 moniker->ulCntData = size;
536 memcpy(moniker->abData, pv, size);
537 GlobalUnlock(hglobal);
538 }
539 }
540 IStream_Release(pStream);
541 IMoniker_Release(pmkObjectName);
542 if (hr != S_OK)
543 {
544 HeapFree(GetProcessHeap(), 0, moniker);
545 rot_entry_delete(rot_entry);
546 return hr;
547 }
548
549
550 while (TRUE)
551 {
552 __TRY
553 {
554 hr = IrotRegister(get_irot_handle(), rot_entry->moniker_data,
555 rot_entry->object, moniker,
556 &rot_entry->last_modified, grfFlags,
557 &rot_entry->cookie, &rot_entry->ctxt_handle);
558 }
559 __EXCEPT(rpc_filter)
560 {
561 hr = HRESULT_FROM_WIN32(GetExceptionCode());
562 }
563 __ENDTRY
564 if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
565 {
566 if (start_rpcss())
567 continue;
568 }
569 break;
570 }
571 HeapFree(GetProcessHeap(), 0, moniker);
572 if (FAILED(hr))
573 {
574 rot_entry_delete(rot_entry);
575 return hr;
576 }
577
578 /* gives a registration identifier to the registered object*/
579 *pdwRegister = rot_entry->cookie;
580
581 EnterCriticalSection(&This->lock);
582 list_add_tail(&This->rot, &rot_entry->entry);
583 LeaveCriticalSection(&This->lock);
584
585 return hr;
586 }
587
588 /***********************************************************************
589 * RunningObjectTable_Revoke
590 *
591 * PARAMS
592 * dwRegister [in] Value identifying registration to be revoked
593 */
594 static HRESULT WINAPI
595 RunningObjectTableImpl_Revoke( IRunningObjectTable* iface, DWORD dwRegister)
596 {
597 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
598 struct rot_entry *rot_entry;
599
600 TRACE("(%p,%d)\n",This,dwRegister);
601
602 EnterCriticalSection(&This->lock);
603 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
604 {
605 if (rot_entry->cookie == dwRegister)
606 {
607 list_remove(&rot_entry->entry);
608 LeaveCriticalSection(&This->lock);
609
610 rot_entry_delete(rot_entry);
611 return S_OK;
612 }
613 }
614 LeaveCriticalSection(&This->lock);
615
616 return E_INVALIDARG;
617 }
618
619 /***********************************************************************
620 * RunningObjectTable_IsRunning
621 *
622 * PARAMS
623 * pmkObjectName [in] moniker of the object whose status is desired
624 */
625 static HRESULT WINAPI
626 RunningObjectTableImpl_IsRunning( IRunningObjectTable* iface, IMoniker *pmkObjectName)
627 {
628 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
629 MonikerComparisonData *moniker_data;
630 HRESULT hr;
631 const struct rot_entry *rot_entry;
632
633 TRACE("(%p,%p)\n",This,pmkObjectName);
634
635 hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
636 if (FAILED(hr))
637 return hr;
638 hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
639 IMoniker_Release(pmkObjectName);
640 if (hr != S_OK)
641 return hr;
642
643 hr = S_FALSE;
644 EnterCriticalSection(&This->lock);
645 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
646 {
647 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
648 !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
649 {
650 hr = S_OK;
651 break;
652 }
653 }
654 LeaveCriticalSection(&This->lock);
655
656 if (hr == S_FALSE)
657 {
658 while (TRUE)
659 {
660 __TRY
661 {
662 hr = IrotIsRunning(get_irot_handle(), moniker_data);
663 }
664 __EXCEPT(rpc_filter)
665 {
666 hr = HRESULT_FROM_WIN32(GetExceptionCode());
667 }
668 __ENDTRY
669 if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
670 {
671 if (start_rpcss())
672 continue;
673 }
674 break;
675 }
676 }
677
678 HeapFree(GetProcessHeap(), 0, moniker_data);
679
680 return hr;
681 }
682
683 /***********************************************************************
684 * RunningObjectTable_GetObject
685 *
686 * PARAMS
687 * pmkObjectName [in] Pointer to the moniker on the object
688 * ppunkObject [out] variable that receives the IUnknown interface pointer
689 */
690 static HRESULT WINAPI
691 RunningObjectTableImpl_GetObject( IRunningObjectTable* iface,
692 IMoniker *pmkObjectName, IUnknown **ppunkObject)
693 {
694 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
695 MonikerComparisonData *moniker_data;
696 InterfaceData *object = NULL;
697 IrotCookie cookie;
698 HRESULT hr;
699 struct rot_entry *rot_entry;
700
701 TRACE("(%p,%p,%p)\n",This,pmkObjectName,ppunkObject);
702
703 if (ppunkObject == NULL)
704 return E_POINTER;
705
706 *ppunkObject = NULL;
707
708 hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
709 if (FAILED(hr))
710 return hr;
711 hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
712 IMoniker_Release(pmkObjectName);
713 if (hr != S_OK)
714 return hr;
715
716 EnterCriticalSection(&This->lock);
717 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
718 {
719 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
720 !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
721 {
722 IStream *pStream;
723 hr = create_stream_on_mip_ro(rot_entry->object, &pStream);
724 if (hr == S_OK)
725 {
726 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
727 IStream_Release(pStream);
728 }
729
730 LeaveCriticalSection(&This->lock);
731 HeapFree(GetProcessHeap(), 0, moniker_data);
732
733 return hr;
734 }
735 }
736 LeaveCriticalSection(&This->lock);
737
738 TRACE("moniker unavailable locally, calling SCM\n");
739
740 while (TRUE)
741 {
742 __TRY
743 {
744 hr = IrotGetObject(get_irot_handle(), moniker_data, &object, &cookie);
745 }
746 __EXCEPT(rpc_filter)
747 {
748 hr = HRESULT_FROM_WIN32(GetExceptionCode());
749 }
750 __ENDTRY
751 if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
752 {
753 if (start_rpcss())
754 continue;
755 }
756 break;
757 }
758
759 if (SUCCEEDED(hr))
760 {
761 IStream *pStream;
762 hr = create_stream_on_mip_ro(object, &pStream);
763 if (hr == S_OK)
764 {
765 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)ppunkObject);
766 IStream_Release(pStream);
767 }
768 }
769 else
770 WARN("Moniker unavailable, IrotGetObject returned 0x%08x\n", hr);
771
772 HeapFree(GetProcessHeap(), 0, moniker_data);
773
774 return hr;
775 }
776
777 /***********************************************************************
778 * RunningObjectTable_NoteChangeTime
779 *
780 * PARAMS
781 * dwRegister [in] Value identifying registration being updated
782 * pfiletime [in] Pointer to structure containing object's last change time
783 */
784 static HRESULT WINAPI
785 RunningObjectTableImpl_NoteChangeTime(IRunningObjectTable* iface,
786 DWORD dwRegister, FILETIME *pfiletime)
787 {
788 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
789 struct rot_entry *rot_entry;
790 HRESULT hr = E_INVALIDARG;
791
792 TRACE("(%p,%d,%p)\n",This,dwRegister,pfiletime);
793
794 EnterCriticalSection(&This->lock);
795 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, struct rot_entry, entry)
796 {
797 if (rot_entry->cookie == dwRegister)
798 {
799 rot_entry->last_modified = *pfiletime;
800 LeaveCriticalSection(&This->lock);
801
802 while (TRUE)
803 {
804 __TRY
805 {
806 hr = IrotNoteChangeTime(get_irot_handle(), dwRegister, pfiletime);
807 }
808 __EXCEPT(rpc_filter)
809 {
810 hr = HRESULT_FROM_WIN32(GetExceptionCode());
811 }
812 __ENDTRY
813 if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
814 {
815 if (start_rpcss())
816 continue;
817 }
818 break;
819 }
820
821 goto done;
822 }
823 }
824 LeaveCriticalSection(&This->lock);
825
826 done:
827 TRACE("-- 0x08%x\n", hr);
828 return hr;
829 }
830
831 /***********************************************************************
832 * RunningObjectTable_GetTimeOfLastChange
833 *
834 * PARAMS
835 * pmkObjectName [in] moniker of the object whose status is desired
836 * pfiletime [out] structure that receives object's last change time
837 */
838 static HRESULT WINAPI
839 RunningObjectTableImpl_GetTimeOfLastChange(IRunningObjectTable* iface,
840 IMoniker *pmkObjectName, FILETIME *pfiletime)
841 {
842 HRESULT hr = MK_E_UNAVAILABLE;
843 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
844 MonikerComparisonData *moniker_data;
845 const struct rot_entry *rot_entry;
846
847 TRACE("(%p,%p,%p)\n",This,pmkObjectName,pfiletime);
848
849 if (pmkObjectName==NULL || pfiletime==NULL)
850 return E_INVALIDARG;
851
852 hr = reduce_moniker(pmkObjectName, NULL, &pmkObjectName);
853 if (FAILED(hr))
854 return hr;
855 hr = get_moniker_comparison_data(pmkObjectName, &moniker_data);
856 IMoniker_Release(pmkObjectName);
857 if (hr != S_OK)
858 return hr;
859
860 hr = MK_E_UNAVAILABLE;
861
862 EnterCriticalSection(&This->lock);
863 LIST_FOR_EACH_ENTRY(rot_entry, &This->rot, const struct rot_entry, entry)
864 {
865 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
866 !memcmp(moniker_data->abData, rot_entry->moniker_data->abData, moniker_data->ulCntData))
867 {
868 *pfiletime = rot_entry->last_modified;
869 hr = S_OK;
870 break;
871 }
872 }
873 LeaveCriticalSection(&This->lock);
874
875 if (hr != S_OK)
876 {
877 while (TRUE)
878 {
879 __TRY
880 {
881 hr = IrotGetTimeOfLastChange(get_irot_handle(), moniker_data, pfiletime);
882 }
883 __EXCEPT(rpc_filter)
884 {
885 hr = HRESULT_FROM_WIN32(GetExceptionCode());
886 }
887 __ENDTRY
888 if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
889 {
890 if (start_rpcss())
891 continue;
892 }
893 break;
894 }
895 }
896
897 HeapFree(GetProcessHeap(), 0, moniker_data);
898
899 TRACE("-- 0x%08x\n", hr);
900 return hr;
901 }
902
903 /***********************************************************************
904 * RunningObjectTable_EnumRunning
905 *
906 * PARAMS
907 * ppenumMoniker [out] receives the IEnumMoniker interface pointer
908 */
909 static HRESULT WINAPI
910 RunningObjectTableImpl_EnumRunning(IRunningObjectTable* iface,
911 IEnumMoniker **ppenumMoniker)
912 {
913 RunningObjectTableImpl *This = impl_from_IRunningObjectTable(iface);
914 InterfaceList *interface_list = NULL;
915 HRESULT hr;
916
917 TRACE("(%p, %p)\n", This, ppenumMoniker);
918
919 *ppenumMoniker = NULL;
920
921 while (TRUE)
922 {
923 __TRY
924 {
925 hr = IrotEnumRunning(get_irot_handle(), &interface_list);
926 }
927 __EXCEPT(rpc_filter)
928 {
929 hr = HRESULT_FROM_WIN32(GetExceptionCode());
930 }
931 __ENDTRY
932 if (hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE))
933 {
934 if (start_rpcss())
935 continue;
936 }
937 break;
938 }
939
940 if (SUCCEEDED(hr))
941 hr = EnumMonikerImpl_CreateEnumROTMoniker(interface_list,
942 0, ppenumMoniker);
943
944 return hr;
945 }
946
947 /* Virtual function table for the IRunningObjectTable class. */
948 static const IRunningObjectTableVtbl VT_RunningObjectTableImpl =
949 {
950 RunningObjectTableImpl_QueryInterface,
951 RunningObjectTableImpl_AddRef,
952 RunningObjectTableImpl_Release,
953 RunningObjectTableImpl_Register,
954 RunningObjectTableImpl_Revoke,
955 RunningObjectTableImpl_IsRunning,
956 RunningObjectTableImpl_GetObject,
957 RunningObjectTableImpl_NoteChangeTime,
958 RunningObjectTableImpl_GetTimeOfLastChange,
959 RunningObjectTableImpl_EnumRunning
960 };
961
962 /***********************************************************************
963 * RunningObjectTable_Initialize
964 */
965 HRESULT WINAPI RunningObjectTableImpl_Initialize(void)
966 {
967 TRACE("\n");
968
969 /* create the unique instance of the RunningObjectTableImpl structure */
970 runningObjectTableInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(RunningObjectTableImpl));
971
972 if (!runningObjectTableInstance)
973 return E_OUTOFMEMORY;
974
975 /* initialize the virtual table function */
976 runningObjectTableInstance->IRunningObjectTable_iface.lpVtbl = &VT_RunningObjectTableImpl;
977
978 /* the initial reference is set to "1" so that it isn't destroyed after its
979 * first use until the process is destroyed, as the running object table is
980 * a process-wide cache of a global table */
981 runningObjectTableInstance->ref = 1;
982
983 list_init(&runningObjectTableInstance->rot);
984 InitializeCriticalSection(&runningObjectTableInstance->lock);
985 DEBUG_SET_CRITSEC_NAME(&runningObjectTableInstance->lock, "RunningObjectTableImpl.lock");
986
987 return S_OK;
988 }
989
990 /***********************************************************************
991 * RunningObjectTable_UnInitialize
992 */
993 HRESULT WINAPI RunningObjectTableImpl_UnInitialize(void)
994 {
995 TRACE("\n");
996
997 if (runningObjectTableInstance==NULL)
998 return E_POINTER;
999
1000 RunningObjectTableImpl_Release(&runningObjectTableInstance->IRunningObjectTable_iface);
1001
1002 RunningObjectTableImpl_Destroy();
1003
1004 return S_OK;
1005 }
1006
1007 /***********************************************************************
1008 * GetRunningObjectTable (OLE32.@)
1009 *
1010 * Retrieves the global running object table.
1011 *
1012 * PARAMS
1013 * reserved [I] Reserved. Set to 0.
1014 * pprot [O] Address that receives the pointer to the running object table.
1015 *
1016 * RETURNS
1017 * Success: S_OK.
1018 * Failure: Any HRESULT code.
1019 */
1020 HRESULT WINAPI
1021 GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot)
1022 {
1023 IID riid=IID_IRunningObjectTable;
1024 HRESULT res;
1025
1026 TRACE("()\n");
1027
1028 if (reserved!=0)
1029 return E_UNEXPECTED;
1030
1031 if(runningObjectTableInstance==NULL)
1032 return CO_E_NOTINITIALIZED;
1033
1034 res = IRunningObjectTable_QueryInterface(&runningObjectTableInstance->IRunningObjectTable_iface,
1035 &riid,(void**)pprot);
1036
1037 return res;
1038 }
1039
1040 static HRESULT get_moniker_for_progid_display_name(LPBC pbc,
1041 LPCOLESTR szDisplayName,
1042 LPDWORD pchEaten,
1043 LPMONIKER *ppmk)
1044 {
1045 CLSID clsid;
1046 HRESULT hr;
1047 LPWSTR progid;
1048 LPCWSTR start = szDisplayName;
1049 LPCWSTR end;
1050 int len;
1051 IMoniker *class_moniker;
1052
1053 if (*start == '@')
1054 start++;
1055
1056 /* find end delimiter */
1057 for (end = start; *end; end++)
1058 if (*end == ':')
1059 break;
1060
1061 len = end - start;
1062
1063 /* must start with '@' or have a ':' somewhere and mustn't be one character
1064 * long (since that looks like an absolute path) */
1065 if (((start == szDisplayName) && (*end == '\0')) || (len <= 1))
1066 return MK_E_SYNTAX;
1067
1068 progid = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1069 if (progid)
1070 {
1071 memcpy(progid, start, len * sizeof(WCHAR));
1072 progid[len] = '\0';
1073 }
1074 hr = CLSIDFromProgID(progid, &clsid);
1075 HeapFree(GetProcessHeap(), 0, progid);
1076 if (FAILED(hr))
1077 return MK_E_SYNTAX;
1078
1079 hr = CreateClassMoniker(&clsid, &class_moniker);
1080 if (SUCCEEDED(hr))
1081 {
1082 IParseDisplayName *pdn;
1083 hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
1084 &IID_IParseDisplayName, (void **)&pdn);
1085 /* fallback to using IClassFactory to get IParseDisplayName -
1086 * adsldp.dll depends on this */
1087 if (FAILED(hr))
1088 {
1089 IClassFactory *pcf;
1090 hr = IMoniker_BindToObject(class_moniker, pbc, NULL,
1091 &IID_IClassFactory, (void **)&pcf);
1092 if (SUCCEEDED(hr))
1093 {
1094 hr = IClassFactory_CreateInstance(pcf, NULL,
1095 &IID_IParseDisplayName,
1096 (void **)&pdn);
1097 IClassFactory_Release(pcf);
1098 }
1099 }
1100 IMoniker_Release(class_moniker);
1101 if (SUCCEEDED(hr))
1102 {
1103 hr = IParseDisplayName_ParseDisplayName(pdn, pbc,
1104 (LPOLESTR)szDisplayName,
1105 pchEaten, ppmk);
1106 IParseDisplayName_Release(pdn);
1107 }
1108 }
1109 return hr;
1110 }
1111
1112 /******************************************************************************
1113 * MkParseDisplayName [OLE32.@]
1114 */
1115 HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szDisplayName,
1116 LPDWORD pchEaten, LPMONIKER *ppmk)
1117 {
1118 HRESULT hr = MK_E_SYNTAX;
1119 static const WCHAR wszClsidColon[] = {'c','l','s','i','d',':'};
1120 IMoniker *moniker;
1121 DWORD chEaten;
1122
1123 TRACE("(%p, %s, %p, %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
1124
1125 if (!pbc || !IsValidInterface((LPUNKNOWN) pbc))
1126 return E_INVALIDARG;
1127
1128 if (!szDisplayName || !*szDisplayName)
1129 return E_INVALIDARG;
1130
1131 if (!pchEaten || !ppmk)
1132 return E_INVALIDARG;
1133
1134 *pchEaten = 0;
1135 *ppmk = NULL;
1136
1137 if (!strncmpiW(szDisplayName, wszClsidColon, sizeof(wszClsidColon)/sizeof(wszClsidColon[0])))
1138 {
1139 hr = ClassMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
1140 if (FAILED(hr) && (hr != MK_E_SYNTAX))
1141 return hr;
1142 }
1143 else
1144 {
1145 hr = get_moniker_for_progid_display_name(pbc, szDisplayName, &chEaten, &moniker);
1146 if (FAILED(hr) && (hr != MK_E_SYNTAX))
1147 return hr;
1148 }
1149
1150 if (FAILED(hr))
1151 {
1152 hr = FileMoniker_CreateFromDisplayName(pbc, szDisplayName, &chEaten, &moniker);
1153 if (FAILED(hr) && (hr != MK_E_SYNTAX))
1154 return hr;
1155 }
1156
1157 if (SUCCEEDED(hr))
1158 {
1159 while (TRUE)
1160 {
1161 IMoniker *next_moniker;
1162 *pchEaten += chEaten;
1163 szDisplayName += chEaten;
1164 if (!*szDisplayName)
1165 {
1166 *ppmk = moniker;
1167 return S_OK;
1168 }
1169 chEaten = 0;
1170 hr = IMoniker_ParseDisplayName(moniker, pbc, NULL,
1171 (LPOLESTR)szDisplayName, &chEaten,
1172 &next_moniker);
1173 IMoniker_Release(moniker);
1174 if (FAILED(hr))
1175 {
1176 *pchEaten = 0;
1177 break;
1178 }
1179 moniker = next_moniker;
1180 }
1181 }
1182
1183 return hr;
1184 }
1185
1186 /***********************************************************************
1187 * GetClassFile (OLE32.@)
1188 *
1189 * Retrieves the class ID associated with the given filename.
1190 *
1191 * PARAMS
1192 * filePathName [I] Filename to retrieve the class ID for.
1193 * pclsid [O] Address that receives the class ID for the file.
1194 *
1195 * RETURNS
1196 * Success: S_OK.
1197 * Failure: Any HRESULT code.
1198 */
1199 HRESULT WINAPI GetClassFile(LPCOLESTR filePathName,CLSID *pclsid)
1200 {
1201 IStorage *pstg=0;
1202 HRESULT res;
1203 int nbElm, length, i;
1204 LONG sizeProgId;
1205 LPOLESTR *pathDec=0,absFile=0,progId=0;
1206 LPWSTR extension;
1207 static const WCHAR bkslashW[] = {'\\',0};
1208 static const WCHAR dotW[] = {'.',0};
1209
1210 TRACE("%s, %p\n", debugstr_w(filePathName), pclsid);
1211
1212 /* if the file contain a storage object the return the CLSID written by IStorage_SetClass method*/
1213 if((StgIsStorageFile(filePathName))==S_OK){
1214
1215 res=StgOpenStorage(filePathName,NULL,STGM_READ | STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
1216
1217 if (SUCCEEDED(res))
1218 res=ReadClassStg(pstg,pclsid);
1219
1220 IStorage_Release(pstg);
1221
1222 return res;
1223 }
1224 /* If the file is not a storage object then attempt to match various bits in the file against a
1225 pattern in the registry. This case is not frequently used, so I present only the pseudocode for
1226 this case.
1227
1228 for(i=0;i<nFileTypes;i++)
1229
1230 for(i=0;j<nPatternsForType;j++){
1231
1232 PATTERN pat;
1233 HANDLE hFile;
1234
1235 pat=ReadPatternFromRegistry(i,j);
1236 hFile=CreateFileW(filePathName,,,,,,hFile);
1237 SetFilePosition(hFile,pat.offset);
1238 ReadFile(hFile,buf,pat.size,&r,NULL);
1239 if (memcmp(buf&pat.mask,pat.pattern.pat.size)==0){
1240
1241 *pclsid=ReadCLSIDFromRegistry(i);
1242 return S_OK;
1243 }
1244 }
1245 */
1246
1247 /* if the above strategies fail then search for the extension key in the registry */
1248
1249 /* get the last element (absolute file) in the path name */
1250 nbElm=FileMonikerImpl_DecomposePath(filePathName,&pathDec);
1251 absFile=pathDec[nbElm-1];
1252
1253 /* failed if the path represents a directory and not an absolute file name*/
1254 if (!lstrcmpW(absFile, bkslashW))
1255 return MK_E_INVALIDEXTENSION;
1256
1257 /* get the extension of the file */
1258 extension = NULL;
1259 length=lstrlenW(absFile);
1260 for(i = length-1; (i >= 0) && *(extension = &absFile[i]) != '.'; i--)
1261 /* nothing */;
1262
1263 if (!extension || !lstrcmpW(extension, dotW))
1264 return MK_E_INVALIDEXTENSION;
1265
1266 res=RegQueryValueW(HKEY_CLASSES_ROOT, extension, NULL, &sizeProgId);
1267
1268 /* get the progId associated to the extension */
1269 progId = CoTaskMemAlloc(sizeProgId);
1270 res = RegQueryValueW(HKEY_CLASSES_ROOT, extension, progId, &sizeProgId);
1271
1272 if (res==ERROR_SUCCESS)
1273 /* return the clsid associated to the progId */
1274 res= CLSIDFromProgID(progId,pclsid);
1275
1276 for(i=0; pathDec[i]!=NULL;i++)
1277 CoTaskMemFree(pathDec[i]);
1278 CoTaskMemFree(pathDec);
1279
1280 CoTaskMemFree(progId);
1281
1282 if (res==ERROR_SUCCESS)
1283 return res;
1284
1285 return MK_E_INVALIDEXTENSION;
1286 }
1287
1288 /***********************************************************************
1289 * EnumMoniker_QueryInterface
1290 */
1291 static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker* iface,REFIID riid,void** ppvObject)
1292 {
1293 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1294
1295 TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
1296
1297 /* validate arguments */
1298 if (ppvObject == NULL)
1299 return E_INVALIDARG;
1300
1301 *ppvObject = NULL;
1302
1303 if (IsEqualIID(&IID_IUnknown, riid))
1304 *ppvObject = This;
1305 else
1306 if (IsEqualIID(&IID_IEnumMoniker, riid))
1307 *ppvObject = This;
1308
1309 if ((*ppvObject)==NULL)
1310 return E_NOINTERFACE;
1311
1312 IEnumMoniker_AddRef(iface);
1313
1314 return S_OK;
1315 }
1316
1317 /***********************************************************************
1318 * EnumMoniker_AddRef
1319 */
1320 static ULONG WINAPI EnumMonikerImpl_AddRef(IEnumMoniker* iface)
1321 {
1322 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1323
1324 TRACE("(%p)\n",This);
1325
1326 return InterlockedIncrement(&This->ref);
1327 }
1328
1329 /***********************************************************************
1330 * EnumMoniker_release
1331 */
1332 static ULONG WINAPI EnumMonikerImpl_Release(IEnumMoniker* iface)
1333 {
1334 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1335 ULONG ref;
1336
1337 TRACE("(%p)\n",This);
1338
1339 ref = InterlockedDecrement(&This->ref);
1340
1341 /* uninitialize rot structure if there's no more reference to it*/
1342 if (ref == 0)
1343 {
1344 ULONG i;
1345
1346 TRACE("(%p) Deleting\n",This);
1347
1348 for (i = 0; i < This->moniker_list->size; i++)
1349 HeapFree(GetProcessHeap(), 0, This->moniker_list->interfaces[i]);
1350 HeapFree(GetProcessHeap(), 0, This->moniker_list);
1351 HeapFree(GetProcessHeap(), 0, This);
1352 }
1353
1354 return ref;
1355 }
1356 /***********************************************************************
1357 * EnumMoniker_Next
1358 */
1359 static HRESULT WINAPI EnumMonikerImpl_Next(IEnumMoniker* iface, ULONG celt, IMoniker** rgelt, ULONG * pceltFetched)
1360 {
1361 ULONG i;
1362 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1363 HRESULT hr = S_OK;
1364
1365 TRACE("(%p) TabCurrentPos %d Tablastindx %d\n", This, This->pos, This->moniker_list->size);
1366
1367 /* retrieve the requested number of moniker from the current position */
1368 for(i = 0; (This->pos < This->moniker_list->size) && (i < celt); i++)
1369 {
1370 IStream *stream;
1371 hr = create_stream_on_mip_ro(This->moniker_list->interfaces[This->pos++], &stream);
1372 if (hr != S_OK) break;
1373 hr = CoUnmarshalInterface(stream, &IID_IMoniker, (void **)&rgelt[i]);
1374 IStream_Release(stream);
1375 if (hr != S_OK) break;
1376 }
1377
1378 if (pceltFetched != NULL)
1379 *pceltFetched= i;
1380
1381 if (hr != S_OK)
1382 return hr;
1383
1384 if (i == celt)
1385 return S_OK;
1386 else
1387 return S_FALSE;
1388
1389 }
1390
1391 /***********************************************************************
1392 * EnumMoniker_Skip
1393 */
1394 static HRESULT WINAPI EnumMonikerImpl_Skip(IEnumMoniker* iface, ULONG celt)
1395 {
1396 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1397
1398 TRACE("(%p)\n",This);
1399
1400 if (This->pos + celt >= This->moniker_list->size)
1401 return S_FALSE;
1402
1403 This->pos += celt;
1404
1405 return S_OK;
1406 }
1407
1408 /***********************************************************************
1409 * EnumMoniker_Reset
1410 */
1411 static HRESULT WINAPI EnumMonikerImpl_Reset(IEnumMoniker* iface)
1412 {
1413 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1414
1415 This->pos = 0; /* set back to start of list */
1416
1417 TRACE("(%p)\n",This);
1418
1419 return S_OK;
1420 }
1421
1422 /***********************************************************************
1423 * EnumMoniker_Clone
1424 */
1425 static HRESULT WINAPI EnumMonikerImpl_Clone(IEnumMoniker* iface, IEnumMoniker ** ppenum)
1426 {
1427 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1428 InterfaceList *moniker_list;
1429 ULONG i;
1430
1431 TRACE("(%p)\n",This);
1432
1433 *ppenum = NULL;
1434
1435 moniker_list = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceList, interfaces[This->moniker_list->size]));
1436 if (!moniker_list)
1437 return E_OUTOFMEMORY;
1438
1439 moniker_list->size = This->moniker_list->size;
1440 for (i = 0; i < This->moniker_list->size; i++)
1441 {
1442 SIZE_T size = FIELD_OFFSET(InterfaceData, abData[This->moniker_list->interfaces[i]->ulCntData]);
1443 moniker_list->interfaces[i] = HeapAlloc(GetProcessHeap(), 0, size);
1444 if (!moniker_list->interfaces[i])
1445 {
1446 ULONG end = i;
1447 for (i = 0; i < end; i++)
1448 HeapFree(GetProcessHeap(), 0, moniker_list->interfaces[i]);
1449 HeapFree(GetProcessHeap(), 0, moniker_list);
1450 return E_OUTOFMEMORY;
1451 }
1452 memcpy(moniker_list->interfaces[i], This->moniker_list->interfaces[i], size);
1453 }
1454
1455 /* copy the enum structure */
1456 return EnumMonikerImpl_CreateEnumROTMoniker(moniker_list, This->pos, ppenum);
1457 }
1458
1459 /* Virtual function table for the IEnumMoniker class. */
1460 static const IEnumMonikerVtbl VT_EnumMonikerImpl =
1461 {
1462 EnumMonikerImpl_QueryInterface,
1463 EnumMonikerImpl_AddRef,
1464 EnumMonikerImpl_Release,
1465 EnumMonikerImpl_Next,
1466 EnumMonikerImpl_Skip,
1467 EnumMonikerImpl_Reset,
1468 EnumMonikerImpl_Clone
1469 };
1470
1471 /***********************************************************************
1472 * EnumMonikerImpl_CreateEnumROTMoniker
1473 * Used by EnumRunning to create the structure and EnumClone
1474 * to copy the structure
1475 */
1476 static HRESULT EnumMonikerImpl_CreateEnumROTMoniker(InterfaceList *moniker_list,
1477 ULONG current_pos,
1478 IEnumMoniker **ppenumMoniker)
1479 {
1480 EnumMonikerImpl* This = NULL;
1481
1482 if (!ppenumMoniker)
1483 return E_INVALIDARG;
1484
1485 This = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
1486 if (!This) return E_OUTOFMEMORY;
1487
1488 TRACE("(%p)\n", This);
1489
1490 /* initialize the virtual table function */
1491 This->IEnumMoniker_iface.lpVtbl = &VT_EnumMonikerImpl;
1492
1493 /* the initial reference is set to "1" */
1494 This->ref = 1; /* set the ref count to one */
1495 This->pos = current_pos; /* Set the list start posn */
1496 This->moniker_list = moniker_list;
1497
1498 *ppenumMoniker = &This->IEnumMoniker_iface;
1499
1500 return S_OK;
1501 }
1502
1503
1504 /* Shared implementation of moniker marshaler based on saving and loading of
1505 * monikers */
1506
1507 typedef struct MonikerMarshal
1508 {
1509 IUnknown IUnknown_iface;
1510 IMarshal IMarshal_iface;
1511
1512 LONG ref;
1513 IMoniker *moniker;
1514 } MonikerMarshal;
1515
1516 static inline MonikerMarshal *impl_from_IUnknown(IUnknown *iface)
1517 {
1518 return CONTAINING_RECORD(iface, MonikerMarshal, IUnknown_iface);
1519 }
1520
1521 static inline MonikerMarshal *impl_from_IMarshal( IMarshal *iface )
1522 {
1523 return CONTAINING_RECORD(iface, MonikerMarshal, IMarshal_iface);
1524 }
1525
1526 static HRESULT WINAPI MonikerMarshalInner_QueryInterface(IUnknown *iface, REFIID riid, LPVOID *ppv)
1527 {
1528 MonikerMarshal *This = impl_from_IUnknown(iface);
1529 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1530 *ppv = NULL;
1531 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid))
1532 {
1533 *ppv = &This->IMarshal_iface;
1534 IUnknown_AddRef((IUnknown *)&This->IMarshal_iface);
1535 return S_OK;
1536 }
1537 FIXME("No interface for %s\n", debugstr_guid(riid));
1538 return E_NOINTERFACE;
1539 }
1540
1541 static ULONG WINAPI MonikerMarshalInner_AddRef(IUnknown *iface)
1542 {
1543 MonikerMarshal *This = impl_from_IUnknown(iface);
1544 return InterlockedIncrement(&This->ref);
1545 }
1546
1547 static ULONG WINAPI MonikerMarshalInner_Release(IUnknown *iface)
1548 {
1549 MonikerMarshal *This = impl_from_IUnknown(iface);
1550 ULONG ref = InterlockedDecrement(&This->ref);
1551
1552 if (!ref) HeapFree(GetProcessHeap(), 0, This);
1553 return ref;
1554 }
1555
1556 static const IUnknownVtbl VT_MonikerMarshalInner =
1557 {
1558 MonikerMarshalInner_QueryInterface,
1559 MonikerMarshalInner_AddRef,
1560 MonikerMarshalInner_Release
1561 };
1562
1563 static HRESULT WINAPI MonikerMarshal_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
1564 {
1565 MonikerMarshal *This = impl_from_IMarshal(iface);
1566 return IMoniker_QueryInterface(This->moniker, riid, ppv);
1567 }
1568
1569 static ULONG WINAPI MonikerMarshal_AddRef(IMarshal *iface)
1570 {
1571 MonikerMarshal *This = impl_from_IMarshal(iface);
1572 return IMoniker_AddRef(This->moniker);
1573 }
1574
1575 static ULONG WINAPI MonikerMarshal_Release(IMarshal *iface)
1576 {
1577 MonikerMarshal *This = impl_from_IMarshal(iface);
1578 return IMoniker_Release(This->moniker);
1579 }
1580
1581 static HRESULT WINAPI MonikerMarshal_GetUnmarshalClass(
1582 LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1583 void* pvDestContext, DWORD mshlflags, CLSID* pCid)
1584 {
1585 MonikerMarshal *This = impl_from_IMarshal(iface);
1586
1587 TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1588 dwDestContext, pvDestContext, mshlflags, pCid);
1589
1590 return IMoniker_GetClassID(This->moniker, pCid);
1591 }
1592
1593 static HRESULT WINAPI MonikerMarshal_GetMarshalSizeMax(
1594 LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext,
1595 void* pvDestContext, DWORD mshlflags, DWORD* pSize)
1596 {
1597 MonikerMarshal *This = impl_from_IMarshal(iface);
1598 HRESULT hr;
1599 ULARGE_INTEGER size;
1600
1601 TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1602 dwDestContext, pvDestContext, mshlflags, pSize);
1603
1604 hr = IMoniker_GetSizeMax(This->moniker, &size);
1605 if (hr == S_OK)
1606 *pSize = (DWORD)size.QuadPart;
1607 return hr;
1608 }
1609
1610 static HRESULT WINAPI MonikerMarshal_MarshalInterface(LPMARSHAL iface, IStream *pStm,
1611 REFIID riid, void* pv, DWORD dwDestContext,
1612 void* pvDestContext, DWORD mshlflags)
1613 {
1614 MonikerMarshal *This = impl_from_IMarshal(iface);
1615
1616 TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv,
1617 dwDestContext, pvDestContext, mshlflags);
1618
1619 return IMoniker_Save(This->moniker, pStm, FALSE);
1620 }
1621
1622 static HRESULT WINAPI MonikerMarshal_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv)
1623 {
1624 MonikerMarshal *This = impl_from_IMarshal(iface);
1625 HRESULT hr;
1626
1627 TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1628
1629 hr = IMoniker_Load(This->moniker, pStm);
1630 if (hr == S_OK)
1631 hr = IMoniker_QueryInterface(This->moniker, riid, ppv);
1632 return hr;
1633 }
1634
1635 static HRESULT WINAPI MonikerMarshal_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm)
1636 {
1637 TRACE("()\n");
1638 /* can't release a state-based marshal as nothing on server side to
1639 * release */
1640 return S_OK;
1641 }
1642
1643 static HRESULT WINAPI MonikerMarshal_DisconnectObject(LPMARSHAL iface, DWORD dwReserved)
1644 {
1645 TRACE("()\n");
1646 /* can't disconnect a state-based marshal as nothing on server side to
1647 * disconnect from */
1648 return S_OK;
1649 }
1650
1651 static const IMarshalVtbl VT_MonikerMarshal =
1652 {
1653 MonikerMarshal_QueryInterface,
1654 MonikerMarshal_AddRef,
1655 MonikerMarshal_Release,
1656 MonikerMarshal_GetUnmarshalClass,
1657 MonikerMarshal_GetMarshalSizeMax,
1658 MonikerMarshal_MarshalInterface,
1659 MonikerMarshal_UnmarshalInterface,
1660 MonikerMarshal_ReleaseMarshalData,
1661 MonikerMarshal_DisconnectObject
1662 };
1663
1664 HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
1665 {
1666 MonikerMarshal *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1667 if (!This) return E_OUTOFMEMORY;
1668
1669 This->IUnknown_iface.lpVtbl = &VT_MonikerMarshalInner;
1670 This->IMarshal_iface.lpVtbl = &VT_MonikerMarshal;
1671 This->ref = 1;
1672 This->moniker = inner;
1673
1674 *outer = &This->IUnknown_iface;
1675 return S_OK;
1676 }
1677
1678 void * __RPC_USER MIDL_user_allocate(SIZE_T size)
1679 {
1680 return HeapAlloc(GetProcessHeap(), 0, size);
1681 }
1682
1683 void __RPC_USER MIDL_user_free(void *p)
1684 {
1685 HeapFree(GetProcessHeap(), 0, p);
1686 }
A free Windows-compatible Operating System