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