projects / reactos.git / blob
? search:


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