?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
combase: Move CoFreeUnusedLibraries().
[wine.git] / dlls / combase / combase.c
blob5752d90d5cc548fca11e3eea897ffb274719ba94
1 /*
2 * Copyright 2005 Juan Lang
3 * Copyright 2005-2006 Robert Shearman (for CodeWeavers)
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #define COBJMACROS
21 #define NONAMELESSUNION
22
23 #include "ntstatus.h"
24 #define WIN32_NO_STATUS
25 #define USE_COM_CONTEXT_DEF
26 #include "objbase.h"
27 #include "oleauto.h"
28 #include "winternl.h"
29
30 #include "wine/debug.h"
31 #include "wine/heap.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(ole);
34
35 #define CHARS_IN_GUID 39
36
37 struct comclassredirect_data
38 {
39 ULONG size;
40 ULONG flags;
41 DWORD model;
42 GUID clsid;
43 GUID alias;
44 GUID clsid2;
45 GUID tlbid;
46 ULONG name_len;
47 ULONG name_offset;
48 ULONG progid_len;
49 ULONG progid_offset;
50 ULONG clrdata_len;
51 ULONG clrdata_offset;
52 DWORD miscstatus;
53 DWORD miscstatuscontent;
54 DWORD miscstatusthumbnail;
55 DWORD miscstatusicon;
56 DWORD miscstatusdocprint;
57 };
58
59 struct progidredirect_data
60 {
61 ULONG size;
62 DWORD reserved;
63 ULONG clsid_offset;
64 };
65
66 static NTSTATUS create_key(HKEY *retkey, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr)
67 {
68 NTSTATUS status = NtCreateKey((HANDLE *)retkey, access, attr, 0, NULL, 0, NULL);
69
70 if (status == STATUS_OBJECT_NAME_NOT_FOUND)
71 {
72 HANDLE subkey, root = attr->RootDirectory;
73 WCHAR *buffer = attr->ObjectName->Buffer;
74 DWORD attrs, pos = 0, i = 0, len = attr->ObjectName->Length / sizeof(WCHAR);
75 UNICODE_STRING str;
76
77 while (i < len && buffer[i] != '\\') i++;
78 if (i == len) return status;
79
80 attrs = attr->Attributes;
81 attr->ObjectName = &str;
82
83 while (i < len)
84 {
85 str.Buffer = buffer + pos;
86 str.Length = (i - pos) * sizeof(WCHAR);
87 status = NtCreateKey(&subkey, access, attr, 0, NULL, 0, NULL);
88 if (attr->RootDirectory != root) NtClose(attr->RootDirectory);
89 if (status) return status;
90 attr->RootDirectory = subkey;
91 while (i < len && buffer[i] == '\\') i++;
92 pos = i;
93 while (i < len && buffer[i] != '\\') i++;
94 }
95 str.Buffer = buffer + pos;
96 str.Length = (i - pos) * sizeof(WCHAR);
97 attr->Attributes = attrs;
98 status = NtCreateKey((HANDLE *)retkey, access, attr, 0, NULL, 0, NULL);
99 if (attr->RootDirectory != root) NtClose(attr->RootDirectory);
100 }
101 return status;
102 }
103
104 static HKEY classes_root_hkey;
105
106 static HKEY create_classes_root_hkey(DWORD access)
107 {
108 HKEY hkey, ret = 0;
109 OBJECT_ATTRIBUTES attr;
110 UNICODE_STRING name;
111
112 attr.Length = sizeof(attr);
113 attr.RootDirectory = 0;
114 attr.ObjectName = &name;
115 attr.Attributes = 0;
116 attr.SecurityDescriptor = NULL;
117 attr.SecurityQualityOfService = NULL;
118 RtlInitUnicodeString(&name, L"\\Registry\\Machine\\Software\\Classes");
119
120 if (create_key( &hkey, access, &attr )) return 0;
121 TRACE( "%s -> %p\n", debugstr_w(attr.ObjectName->Buffer), hkey );
122
123 if (!(access & KEY_WOW64_64KEY))
124 {
125 if (!(ret = InterlockedCompareExchangePointer( (void **)&classes_root_hkey, hkey, 0 )))
126 ret = hkey;
127 else
128 NtClose( hkey ); /* somebody beat us to it */
129 }
130 else
131 ret = hkey;
132 return ret;
133 }
134
135 static HKEY get_classes_root_hkey(HKEY hkey, REGSAM access);
136
137 static LSTATUS create_classes_key(HKEY hkey, const WCHAR *name, REGSAM access, HKEY *retkey)
138 {
139 OBJECT_ATTRIBUTES attr;
140 UNICODE_STRING nameW;
141
142 if (!(hkey = get_classes_root_hkey(hkey, access)))
143 return ERROR_INVALID_HANDLE;
144
145 attr.Length = sizeof(attr);
146 attr.RootDirectory = hkey;
147 attr.ObjectName = &nameW;
148 attr.Attributes = 0;
149 attr.SecurityDescriptor = NULL;
150 attr.SecurityQualityOfService = NULL;
151 RtlInitUnicodeString( &nameW, name );
152
153 return RtlNtStatusToDosError(create_key(retkey, access, &attr));
154 }
155
156 static HKEY get_classes_root_hkey(HKEY hkey, REGSAM access)
157 {
158 HKEY ret = hkey;
159 const BOOL is_win64 = sizeof(void*) > sizeof(int);
160 const BOOL force_wow32 = is_win64 && (access & KEY_WOW64_32KEY);
161
162 if (hkey == HKEY_CLASSES_ROOT &&
163 ((access & KEY_WOW64_64KEY) || !(ret = classes_root_hkey)))
164 ret = create_classes_root_hkey(MAXIMUM_ALLOWED | (access & KEY_WOW64_64KEY));
165 if (force_wow32 && ret && ret == classes_root_hkey)
166 {
167 access &= ~KEY_WOW64_32KEY;
168 if (create_classes_key(classes_root_hkey, L"Wow6432Node", access, &hkey))
169 return 0;
170 ret = hkey;
171 }
172
173 return ret;
174 }
175
176 static LSTATUS open_classes_key(HKEY hkey, const WCHAR *name, REGSAM access, HKEY *retkey)
177 {
178 OBJECT_ATTRIBUTES attr;
179 UNICODE_STRING nameW;
180
181 if (!(hkey = get_classes_root_hkey(hkey, access)))
182 return ERROR_INVALID_HANDLE;
183
184 attr.Length = sizeof(attr);
185 attr.RootDirectory = hkey;
186 attr.ObjectName = &nameW;
187 attr.Attributes = 0;
188 attr.SecurityDescriptor = NULL;
189 attr.SecurityQualityOfService = NULL;
190 RtlInitUnicodeString( &nameW, name );
191
192 return RtlNtStatusToDosError(NtOpenKey((HANDLE *)retkey, access, &attr));
193 }
194
195 static HRESULT open_key_for_clsid(REFCLSID clsid, const WCHAR *keyname, REGSAM access, HKEY *subkey)
196 {
197 static const WCHAR clsidW[] = L"CLSID\\";
198 WCHAR path[CHARS_IN_GUID + ARRAY_SIZE(clsidW) - 1];
199 LONG res;
200 HKEY key;
201
202 lstrcpyW(path, clsidW);
203 StringFromGUID2(clsid, path + lstrlenW(clsidW), CHARS_IN_GUID);
204 res = open_classes_key(HKEY_CLASSES_ROOT, path, keyname ? KEY_READ : access, &key);
205 if (res == ERROR_FILE_NOT_FOUND)
206 return REGDB_E_CLASSNOTREG;
207 else if (res != ERROR_SUCCESS)
208 return REGDB_E_READREGDB;
209
210 if (!keyname)
211 {
212 *subkey = key;
213 return S_OK;
214 }
215
216 res = open_classes_key(key, keyname, access, subkey);
217 RegCloseKey(key);
218 if (res == ERROR_FILE_NOT_FOUND)
219 return REGDB_E_KEYMISSING;
220 else if (res != ERROR_SUCCESS)
221 return REGDB_E_READREGDB;
222
223 return S_OK;
224 }
225
226 /***********************************************************************
227 * FreePropVariantArray (combase.@)
228 */
229 HRESULT WINAPI FreePropVariantArray(ULONG count, PROPVARIANT *rgvars)
230 {
231 ULONG i;
232
233 TRACE("%u, %p.\n", count, rgvars);
234
235 if (!rgvars)
236 return E_INVALIDARG;
237
238 for (i = 0; i < count; ++i)
239 PropVariantClear(&rgvars[i]);
240
241 return S_OK;
242 }
243
244 static HRESULT propvar_validatetype(VARTYPE vt)
245 {
246 switch (vt)
247 {
248 case VT_EMPTY:
249 case VT_NULL:
250 case VT_I1:
251 case VT_I2:
252 case VT_I4:
253 case VT_I8:
254 case VT_R4:
255 case VT_R8:
256 case VT_CY:
257 case VT_DATE:
258 case VT_BSTR:
259 case VT_ERROR:
260 case VT_BOOL:
261 case VT_DECIMAL:
262 case VT_UI1:
263 case VT_UI2:
264 case VT_UI4:
265 case VT_UI8:
266 case VT_INT:
267 case VT_UINT:
268 case VT_LPSTR:
269 case VT_LPWSTR:
270 case VT_FILETIME:
271 case VT_BLOB:
272 case VT_DISPATCH:
273 case VT_UNKNOWN:
274 case VT_STREAM:
275 case VT_STORAGE:
276 case VT_STREAMED_OBJECT:
277 case VT_STORED_OBJECT:
278 case VT_BLOB_OBJECT:
279 case VT_CF:
280 case VT_CLSID:
281 case VT_I1|VT_VECTOR:
282 case VT_I2|VT_VECTOR:
283 case VT_I4|VT_VECTOR:
284 case VT_I8|VT_VECTOR:
285 case VT_R4|VT_VECTOR:
286 case VT_R8|VT_VECTOR:
287 case VT_CY|VT_VECTOR:
288 case VT_DATE|VT_VECTOR:
289 case VT_BSTR|VT_VECTOR:
290 case VT_ERROR|VT_VECTOR:
291 case VT_BOOL|VT_VECTOR:
292 case VT_VARIANT|VT_VECTOR:
293 case VT_UI1|VT_VECTOR:
294 case VT_UI2|VT_VECTOR:
295 case VT_UI4|VT_VECTOR:
296 case VT_UI8|VT_VECTOR:
297 case VT_LPSTR|VT_VECTOR:
298 case VT_LPWSTR|VT_VECTOR:
299 case VT_FILETIME|VT_VECTOR:
300 case VT_CF|VT_VECTOR:
301 case VT_CLSID|VT_VECTOR:
302 case VT_ARRAY|VT_I1:
303 case VT_ARRAY|VT_UI1:
304 case VT_ARRAY|VT_I2:
305 case VT_ARRAY|VT_UI2:
306 case VT_ARRAY|VT_I4:
307 case VT_ARRAY|VT_UI4:
308 case VT_ARRAY|VT_INT:
309 case VT_ARRAY|VT_UINT:
310 case VT_ARRAY|VT_R4:
311 case VT_ARRAY|VT_R8:
312 case VT_ARRAY|VT_CY:
313 case VT_ARRAY|VT_DATE:
314 case VT_ARRAY|VT_BSTR:
315 case VT_ARRAY|VT_BOOL:
316 case VT_ARRAY|VT_DECIMAL:
317 case VT_ARRAY|VT_DISPATCH:
318 case VT_ARRAY|VT_UNKNOWN:
319 case VT_ARRAY|VT_ERROR:
320 case VT_ARRAY|VT_VARIANT:
321 return S_OK;
322 }
323 WARN("Bad type %d\n", vt);
324 return STG_E_INVALIDPARAMETER;
325 }
326
327 static void propvar_free_cf_array(ULONG count, CLIPDATA *data)
328 {
329 ULONG i;
330 for (i = 0; i < count; ++i)
331 CoTaskMemFree(data[i].pClipData);
332 }
333
334 /***********************************************************************
335 * PropVariantClear (combase.@)
336 */
337 HRESULT WINAPI PropVariantClear(PROPVARIANT *pvar)
338 {
339 HRESULT hr;
340
341 TRACE("%p.\n", pvar);
342
343 if (!pvar)
344 return S_OK;
345
346 hr = propvar_validatetype(pvar->vt);
347 if (FAILED(hr))
348 {
349 memset(pvar, 0, sizeof(*pvar));
350 return hr;
351 }
352
353 switch (pvar->vt)
354 {
355 case VT_EMPTY:
356 case VT_NULL:
357 case VT_I1:
358 case VT_I2:
359 case VT_I4:
360 case VT_I8:
361 case VT_R4:
362 case VT_R8:
363 case VT_CY:
364 case VT_DATE:
365 case VT_ERROR:
366 case VT_BOOL:
367 case VT_DECIMAL:
368 case VT_UI1:
369 case VT_UI2:
370 case VT_UI4:
371 case VT_UI8:
372 case VT_INT:
373 case VT_UINT:
374 case VT_FILETIME:
375 break;
376 case VT_DISPATCH:
377 case VT_UNKNOWN:
378 case VT_STREAM:
379 case VT_STREAMED_OBJECT:
380 case VT_STORAGE:
381 case VT_STORED_OBJECT:
382 if (pvar->u.pStream)
383 IStream_Release(pvar->u.pStream);
384 break;
385 case VT_CLSID:
386 case VT_LPSTR:
387 case VT_LPWSTR:
388 /* pick an arbitrary typed pointer - we don't care about the type
389 * as we are just freeing it */
390 CoTaskMemFree(pvar->u.puuid);
391 break;
392 case VT_BLOB:
393 case VT_BLOB_OBJECT:
394 CoTaskMemFree(pvar->u.blob.pBlobData);
395 break;
396 case VT_BSTR:
397 SysFreeString(pvar->u.bstrVal);
398 break;
399 case VT_CF:
400 if (pvar->u.pclipdata)
401 {
402 propvar_free_cf_array(1, pvar->u.pclipdata);
403 CoTaskMemFree(pvar->u.pclipdata);
404 }
405 break;
406 default:
407 if (pvar->vt & VT_VECTOR)
408 {
409 ULONG i;
410
411 switch (pvar->vt & ~VT_VECTOR)
412 {
413 case VT_VARIANT:
414 FreePropVariantArray(pvar->u.capropvar.cElems, pvar->u.capropvar.pElems);
415 break;
416 case VT_CF:
417 propvar_free_cf_array(pvar->u.caclipdata.cElems, pvar->u.caclipdata.pElems);
418 break;
419 case VT_BSTR:
420 for (i = 0; i < pvar->u.cabstr.cElems; i++)
421 SysFreeString(pvar->u.cabstr.pElems[i]);
422 break;
423 case VT_LPSTR:
424 for (i = 0; i < pvar->u.calpstr.cElems; i++)
425 CoTaskMemFree(pvar->u.calpstr.pElems[i]);
426 break;
427 case VT_LPWSTR:
428 for (i = 0; i < pvar->u.calpwstr.cElems; i++)
429 CoTaskMemFree(pvar->u.calpwstr.pElems[i]);
430 break;
431 }
432 if (pvar->vt & ~VT_VECTOR)
433 {
434 /* pick an arbitrary VT_VECTOR structure - they all have the same
435 * memory layout */
436 CoTaskMemFree(pvar->u.capropvar.pElems);
437 }
438 }
439 else if (pvar->vt & VT_ARRAY)
440 hr = SafeArrayDestroy(pvar->u.parray);
441 else
442 {
443 WARN("Invalid/unsupported type %d\n", pvar->vt);
444 hr = STG_E_INVALIDPARAMETER;
445 }
446 }
447
448 memset(pvar, 0, sizeof(*pvar));
449 return hr;
450 }
451
452 /***********************************************************************
453 * PropVariantCopy (combase.@)
454 */
455 HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest, const PROPVARIANT *pvarSrc)
456 {
457 ULONG len;
458 HRESULT hr;
459
460 TRACE("%p, %p vt %04x.\n", pvarDest, pvarSrc, pvarSrc->vt);
461
462 hr = propvar_validatetype(pvarSrc->vt);
463 if (FAILED(hr))
464 return DISP_E_BADVARTYPE;
465
466 /* this will deal with most cases */
467 *pvarDest = *pvarSrc;
468
469 switch (pvarSrc->vt)
470 {
471 case VT_EMPTY:
472 case VT_NULL:
473 case VT_I1:
474 case VT_UI1:
475 case VT_I2:
476 case VT_UI2:
477 case VT_BOOL:
478 case VT_DECIMAL:
479 case VT_I4:
480 case VT_UI4:
481 case VT_R4:
482 case VT_ERROR:
483 case VT_I8:
484 case VT_UI8:
485 case VT_INT:
486 case VT_UINT:
487 case VT_R8:
488 case VT_CY:
489 case VT_DATE:
490 case VT_FILETIME:
491 break;
492 case VT_DISPATCH:
493 case VT_UNKNOWN:
494 case VT_STREAM:
495 case VT_STREAMED_OBJECT:
496 case VT_STORAGE:
497 case VT_STORED_OBJECT:
498 if (pvarDest->u.pStream)
499 IStream_AddRef(pvarDest->u.pStream);
500 break;
501 case VT_CLSID:
502 pvarDest->u.puuid = CoTaskMemAlloc(sizeof(CLSID));
503 *pvarDest->u.puuid = *pvarSrc->u.puuid;
504 break;
505 case VT_LPSTR:
506 if (pvarSrc->u.pszVal)
507 {
508 len = strlen(pvarSrc->u.pszVal);
509 pvarDest->u.pszVal = CoTaskMemAlloc((len+1)*sizeof(CHAR));
510 CopyMemory(pvarDest->u.pszVal, pvarSrc->u.pszVal, (len+1)*sizeof(CHAR));
511 }
512 break;
513 case VT_LPWSTR:
514 if (pvarSrc->u.pwszVal)
515 {
516 len = lstrlenW(pvarSrc->u.pwszVal);
517 pvarDest->u.pwszVal = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
518 CopyMemory(pvarDest->u.pwszVal, pvarSrc->u.pwszVal, (len+1)*sizeof(WCHAR));
519 }
520 break;
521 case VT_BLOB:
522 case VT_BLOB_OBJECT:
523 if (pvarSrc->u.blob.pBlobData)
524 {
525 len = pvarSrc->u.blob.cbSize;
526 pvarDest->u.blob.pBlobData = CoTaskMemAlloc(len);
527 CopyMemory(pvarDest->u.blob.pBlobData, pvarSrc->u.blob.pBlobData, len);
528 }
529 break;
530 case VT_BSTR:
531 pvarDest->u.bstrVal = SysAllocString(pvarSrc->u.bstrVal);
532 break;
533 case VT_CF:
534 if (pvarSrc->u.pclipdata)
535 {
536 len = pvarSrc->u.pclipdata->cbSize - sizeof(pvarSrc->u.pclipdata->ulClipFmt);
537 pvarDest->u.pclipdata = CoTaskMemAlloc(sizeof (CLIPDATA));
538 pvarDest->u.pclipdata->cbSize = pvarSrc->u.pclipdata->cbSize;
539 pvarDest->u.pclipdata->ulClipFmt = pvarSrc->u.pclipdata->ulClipFmt;
540 pvarDest->u.pclipdata->pClipData = CoTaskMemAlloc(len);
541 CopyMemory(pvarDest->u.pclipdata->pClipData, pvarSrc->u.pclipdata->pClipData, len);
542 }
543 break;
544 default:
545 if (pvarSrc->vt & VT_VECTOR)
546 {
547 int elemSize;
548 ULONG i;
549
550 switch (pvarSrc->vt & ~VT_VECTOR)
551 {
552 case VT_I1: elemSize = sizeof(pvarSrc->u.cVal); break;
553 case VT_UI1: elemSize = sizeof(pvarSrc->u.bVal); break;
554 case VT_I2: elemSize = sizeof(pvarSrc->u.iVal); break;
555 case VT_UI2: elemSize = sizeof(pvarSrc->u.uiVal); break;
556 case VT_BOOL: elemSize = sizeof(pvarSrc->u.boolVal); break;
557 case VT_I4: elemSize = sizeof(pvarSrc->u.lVal); break;
558 case VT_UI4: elemSize = sizeof(pvarSrc->u.ulVal); break;
559 case VT_R4: elemSize = sizeof(pvarSrc->u.fltVal); break;
560 case VT_R8: elemSize = sizeof(pvarSrc->u.dblVal); break;
561 case VT_ERROR: elemSize = sizeof(pvarSrc->u.scode); break;
562 case VT_I8: elemSize = sizeof(pvarSrc->u.hVal); break;
563 case VT_UI8: elemSize = sizeof(pvarSrc->u.uhVal); break;
564 case VT_CY: elemSize = sizeof(pvarSrc->u.cyVal); break;
565 case VT_DATE: elemSize = sizeof(pvarSrc->u.date); break;
566 case VT_FILETIME: elemSize = sizeof(pvarSrc->u.filetime); break;
567 case VT_CLSID: elemSize = sizeof(*pvarSrc->u.puuid); break;
568 case VT_CF: elemSize = sizeof(*pvarSrc->u.pclipdata); break;
569 case VT_BSTR: elemSize = sizeof(pvarSrc->u.bstrVal); break;
570 case VT_LPSTR: elemSize = sizeof(pvarSrc->u.pszVal); break;
571 case VT_LPWSTR: elemSize = sizeof(pvarSrc->u.pwszVal); break;
572 case VT_VARIANT: elemSize = sizeof(*pvarSrc->u.pvarVal); break;
573
574 default:
575 FIXME("Invalid element type: %ul\n", pvarSrc->vt & ~VT_VECTOR);
576 return E_INVALIDARG;
577 }
578 len = pvarSrc->u.capropvar.cElems;
579 pvarDest->u.capropvar.pElems = len ? CoTaskMemAlloc(len * elemSize) : NULL;
580 if (pvarSrc->vt == (VT_VECTOR | VT_VARIANT))
581 {
582 for (i = 0; i < len; i++)
583 PropVariantCopy(&pvarDest->u.capropvar.pElems[i], &pvarSrc->u.capropvar.pElems[i]);
584 }
585 else if (pvarSrc->vt == (VT_VECTOR | VT_CF))
586 {
587 FIXME("Copy clipformats\n");
588 }
589 else if (pvarSrc->vt == (VT_VECTOR | VT_BSTR))
590 {
591 for (i = 0; i < len; i++)
592 pvarDest->u.cabstr.pElems[i] = SysAllocString(pvarSrc->u.cabstr.pElems[i]);
593 }
594 else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
595 {
596 size_t strLen;
597 for (i = 0; i < len; i++)
598 {
599 strLen = lstrlenA(pvarSrc->u.calpstr.pElems[i]) + 1;
600 pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
601 memcpy(pvarDest->u.calpstr.pElems[i],
602 pvarSrc->u.calpstr.pElems[i], strLen);
603 }
604 }
605 else if (pvarSrc->vt == (VT_VECTOR | VT_LPWSTR))
606 {
607 size_t strLen;
608 for (i = 0; i < len; i++)
609 {
610 strLen = (lstrlenW(pvarSrc->u.calpwstr.pElems[i]) + 1) *
611 sizeof(WCHAR);
612 pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
613 memcpy(pvarDest->u.calpstr.pElems[i],
614 pvarSrc->u.calpstr.pElems[i], strLen);
615 }
616 }
617 else
618 CopyMemory(pvarDest->u.capropvar.pElems, pvarSrc->u.capropvar.pElems, len * elemSize);
619 }
620 else if (pvarSrc->vt & VT_ARRAY)
621 {
622 pvarDest->u.uhVal.QuadPart = 0;
623 return SafeArrayCopy(pvarSrc->u.parray, &pvarDest->u.parray);
624 }
625 else
626 WARN("Invalid/unsupported type %d\n", pvarSrc->vt);
627 }
628
629 return S_OK;
630 }
631
632 /***********************************************************************
633 * CoFileTimeNow (combase.@)
634 */
635 HRESULT WINAPI CoFileTimeNow(FILETIME *filetime)
636 {
637 GetSystemTimeAsFileTime(filetime);
638 return S_OK;
639 }
640
641 /******************************************************************************
642 * CoCreateGuid (combase.@)
643 */
644 HRESULT WINAPI CoCreateGuid(GUID *guid)
645 {
646 RPC_STATUS status;
647
648 if (!guid) return E_INVALIDARG;
649
650 status = UuidCreate(guid);
651 if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY) return S_OK;
652 return HRESULT_FROM_WIN32(status);
653 }
654
655 /******************************************************************************
656 * CoQueryProxyBlanket (combase.@)
657 */
658 HRESULT WINAPI CoQueryProxyBlanket(IUnknown *proxy, DWORD *authn_service,
659 DWORD *authz_service, OLECHAR **servername, DWORD *authn_level,
660 DWORD *imp_level, void **auth_info, DWORD *capabilities)
661 {
662 IClientSecurity *client_security;
663 HRESULT hr;
664
665 TRACE("%p, %p, %p, %p, %p, %p, %p, %p.\n", proxy, authn_service, authz_service, servername, authn_level, imp_level,
666 auth_info, capabilities);
667
668 hr = IUnknown_QueryInterface(proxy, &IID_IClientSecurity, (void **)&client_security);
669 if (SUCCEEDED(hr))
670 {
671 hr = IClientSecurity_QueryBlanket(client_security, proxy, authn_service, authz_service, servername,
672 authn_level, imp_level, auth_info, capabilities);
673 IClientSecurity_Release(client_security);
674 }
675
676 if (FAILED(hr)) ERR("-- failed with %#x.\n", hr);
677 return hr;
678 }
679
680 /******************************************************************************
681 * CoSetProxyBlanket (combase.@)
682 */
683 HRESULT WINAPI CoSetProxyBlanket(IUnknown *proxy, DWORD authn_service, DWORD authz_service,
684 OLECHAR *servername, DWORD authn_level, DWORD imp_level, void *auth_info, DWORD capabilities)
685 {
686 IClientSecurity *client_security;
687 HRESULT hr;
688
689 TRACE("%p, %u, %u, %p, %u, %u, %p, %#x.\n", proxy, authn_service, authz_service, servername,
690 authn_level, imp_level, auth_info, capabilities);
691
692 hr = IUnknown_QueryInterface(proxy, &IID_IClientSecurity, (void **)&client_security);
693 if (SUCCEEDED(hr))
694 {
695 hr = IClientSecurity_SetBlanket(client_security, proxy, authn_service, authz_service, servername, authn_level,
696 imp_level, auth_info, capabilities);
697 IClientSecurity_Release(client_security);
698 }
699
700 if (FAILED(hr)) ERR("-- failed with %#x.\n", hr);
701 return hr;
702 }
703
704 /***********************************************************************
705 * CoCopyProxy (combase.@)
706 */
707 HRESULT WINAPI CoCopyProxy(IUnknown *proxy, IUnknown **proxy_copy)
708 {
709 IClientSecurity *client_security;
710 HRESULT hr;
711
712 TRACE("%p, %p.\n", proxy, proxy_copy);
713
714 hr = IUnknown_QueryInterface(proxy, &IID_IClientSecurity, (void **)&client_security);
715 if (SUCCEEDED(hr))
716 {
717 hr = IClientSecurity_CopyProxy(client_security, proxy, proxy_copy);
718 IClientSecurity_Release(client_security);
719 }
720
721 if (FAILED(hr)) ERR("-- failed with %#x.\n", hr);
722 return hr;
723 }
724
725 /***********************************************************************
726 * CoQueryClientBlanket (combase.@)
727 */
728 HRESULT WINAPI CoQueryClientBlanket(DWORD *authn_service, DWORD *authz_service, OLECHAR **servername,
729 DWORD *authn_level, DWORD *imp_level, RPC_AUTHZ_HANDLE *privs, DWORD *capabilities)
730 {
731 IServerSecurity *server_security;
732 HRESULT hr;
733
734 TRACE("%p, %p, %p, %p, %p, %p, %p.\n", authn_service, authz_service, servername, authn_level, imp_level,
735 privs, capabilities);
736
737 hr = CoGetCallContext(&IID_IServerSecurity, (void **)&server_security);
738 if (SUCCEEDED(hr))
739 {
740 hr = IServerSecurity_QueryBlanket(server_security, authn_service, authz_service, servername, authn_level,
741 imp_level, privs, capabilities);
742 IServerSecurity_Release(server_security);
743 }
744
745 return hr;
746 }
747
748 /***********************************************************************
749 * CoImpersonateClient (combase.@)
750 */
751 HRESULT WINAPI CoImpersonateClient(void)
752 {
753 IServerSecurity *server_security;
754 HRESULT hr;
755
756 TRACE("\n");
757
758 hr = CoGetCallContext(&IID_IServerSecurity, (void **)&server_security);
759 if (SUCCEEDED(hr))
760 {
761 hr = IServerSecurity_ImpersonateClient(server_security);
762 IServerSecurity_Release(server_security);
763 }
764
765 return hr;
766 }
767
768 /***********************************************************************
769 * CoRevertToSelf (combase.@)
770 */
771 HRESULT WINAPI CoRevertToSelf(void)
772 {
773 IServerSecurity *server_security;
774 HRESULT hr;
775
776 TRACE("\n");
777
778 hr = CoGetCallContext(&IID_IServerSecurity, (void **)&server_security);
779 if (SUCCEEDED(hr))
780 {
781 hr = IServerSecurity_RevertToSelf(server_security);
782 IServerSecurity_Release(server_security);
783 }
784
785 return hr;
786 }
787
788 /***********************************************************************
789 * CoGetObjectContext (combase.@)
790 */
791 HRESULT WINAPI CoGetObjectContext(REFIID riid, void **ppv)
792 {
793 IObjContext *context;
794 HRESULT hr;
795
796 TRACE("%s, %p.\n", debugstr_guid(riid), ppv);
797
798 *ppv = NULL;
799 hr = CoGetContextToken((ULONG_PTR *)&context);
800 if (FAILED(hr))
801 return hr;
802
803 return IObjContext_QueryInterface(context, riid, ppv);
804 }
805
806 /***********************************************************************
807 * CoGetDefaultContext (combase.@)
808 */
809 HRESULT WINAPI CoGetDefaultContext(APTTYPE type, REFIID riid, void **obj)
810 {
811 FIXME("%d, %s, %p stub\n", type, debugstr_guid(riid), obj);
812
813 return E_NOINTERFACE;
814 }
815
816 /***********************************************************************
817 * CoGetCallState (combase.@)
818 */
819 HRESULT WINAPI CoGetCallState(int arg1, ULONG *arg2)
820 {
821 FIXME("%d, %p.\n", arg1, arg2);
822
823 return E_NOTIMPL;
824 }
825
826 /***********************************************************************
827 * CoGetActivationState (combase.@)
828 */
829 HRESULT WINAPI CoGetActivationState(GUID guid, DWORD arg2, DWORD *arg3)
830 {
831 FIXME("%s, %x, %p.\n", debugstr_guid(&guid), arg2, arg3);
832
833 return E_NOTIMPL;
834 }
835
836 /******************************************************************************
837 * CoGetTreatAsClass (combase.@)
838 */
839 HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, CLSID *clsidNew)
840 {
841 WCHAR buffW[CHARS_IN_GUID];
842 LONG len = sizeof(buffW);
843 HRESULT hr = S_OK;
844 HKEY hkey = NULL;
845
846 TRACE("%s, %p.\n", debugstr_guid(clsidOld), clsidNew);
847
848 if (!clsidOld || !clsidNew)
849 return E_INVALIDARG;
850
851 *clsidNew = *clsidOld;
852
853 hr = open_key_for_clsid(clsidOld, L"TreatAs", KEY_READ, &hkey);
854 if (FAILED(hr))
855 {
856 hr = S_FALSE;
857 goto done;
858 }
859
860 if (RegQueryValueW(hkey, NULL, buffW, &len))
861 {
862 hr = S_FALSE;
863 goto done;
864 }
865
866 hr = CLSIDFromString(buffW, clsidNew);
867 if (FAILED(hr))
868 ERR("Failed to get CLSID from string %s, hr %#x.\n", debugstr_w(buffW), hr);
869 done:
870 if (hkey) RegCloseKey(hkey);
871 return hr;
872 }
873
874 /******************************************************************************
875 * ProgIDFromCLSID (combase.@)
876 */
877 HRESULT WINAPI DECLSPEC_HOTPATCH ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *progid)
878 {
879 ACTCTX_SECTION_KEYED_DATA data;
880 LONG progidlen = 0;
881 HKEY hkey;
882 HRESULT hr;
883
884 if (!progid)
885 return E_INVALIDARG;
886
887 *progid = NULL;
888
889 data.cbSize = sizeof(data);
890 if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
891 clsid, &data))
892 {
893 struct comclassredirect_data *comclass = (struct comclassredirect_data *)data.lpData;
894 if (comclass->progid_len)
895 {
896 WCHAR *ptrW;
897
898 *progid = CoTaskMemAlloc(comclass->progid_len + sizeof(WCHAR));
899 if (!*progid) return E_OUTOFMEMORY;
900
901 ptrW = (WCHAR *)((BYTE *)comclass + comclass->progid_offset);
902 memcpy(*progid, ptrW, comclass->progid_len + sizeof(WCHAR));
903 return S_OK;
904 }
905 else
906 return REGDB_E_CLASSNOTREG;
907 }
908
909 hr = open_key_for_clsid(clsid, L"ProgID", KEY_READ, &hkey);
910 if (FAILED(hr))
911 return hr;
912
913 if (RegQueryValueW(hkey, NULL, NULL, &progidlen))
914 hr = REGDB_E_CLASSNOTREG;
915
916 if (hr == S_OK)
917 {
918 *progid = CoTaskMemAlloc(progidlen * sizeof(WCHAR));
919 if (*progid)
920 {
921 if (RegQueryValueW(hkey, NULL, *progid, &progidlen))
922 {
923 hr = REGDB_E_CLASSNOTREG;
924 CoTaskMemFree(*progid);
925 *progid = NULL;
926 }
927 }
928 else
929 hr = E_OUTOFMEMORY;
930 }
931
932 RegCloseKey(hkey);
933 return hr;
934 }
935
936 static inline BOOL is_valid_hex(WCHAR c)
937 {
938 if (!(((c >= '0') && (c <= '9')) ||
939 ((c >= 'a') && (c <= 'f')) ||
940 ((c >= 'A') && (c <= 'F'))))
941 return FALSE;
942 return TRUE;
943 }
944
945 static const BYTE guid_conv_table[256] =
946 {
947 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
948 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
949 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
950 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
951 0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
952 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
953 0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf /* 0x60 */
954 };
955
956 static BOOL guid_from_string(LPCWSTR s, GUID *id)
957 {
958 int i;
959
960 if (!s || s[0] != '{')
961 {
962 memset(id, 0, sizeof(*id));
963 if (!s) return TRUE;
964 return FALSE;
965 }
966
967 TRACE("%s -> %p\n", debugstr_w(s), id);
968
969 /* In form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
970
971 id->Data1 = 0;
972 for (i = 1; i < 9; ++i)
973 {
974 if (!is_valid_hex(s[i])) return FALSE;
975 id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
976 }
977 if (s[9] != '-') return FALSE;
978
979 id->Data2 = 0;
980 for (i = 10; i < 14; ++i)
981 {
982 if (!is_valid_hex(s[i])) return FALSE;
983 id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
984 }
985 if (s[14] != '-') return FALSE;
986
987 id->Data3 = 0;
988 for (i = 15; i < 19; ++i)
989 {
990 if (!is_valid_hex(s[i])) return FALSE;
991 id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
992 }
993 if (s[19] != '-') return FALSE;
994
995 for (i = 20; i < 37; i += 2)
996 {
997 if (i == 24)
998 {
999 if (s[i] != '-') return FALSE;
1000 i++;
1001 }
1002 if (!is_valid_hex(s[i]) || !is_valid_hex(s[i + 1])) return FALSE;
1003 id->Data4[(i - 20) / 2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i + 1]];
1004 }
1005
1006 if (s[37] == '}' && s[38] == '\0')
1007 return TRUE;
1008
1009 return FALSE;
1010 }
1011
1012 static HRESULT clsid_from_string_reg(LPCOLESTR progid, CLSID *clsid)
1013 {
1014 WCHAR buf2[CHARS_IN_GUID];
1015 LONG buf2len = sizeof(buf2);
1016 HKEY xhkey;
1017 WCHAR *buf;
1018
1019 memset(clsid, 0, sizeof(*clsid));
1020 buf = heap_alloc((lstrlenW(progid) + 8) * sizeof(WCHAR));
1021 if (!buf) return E_OUTOFMEMORY;
1022
1023 lstrcpyW(buf, progid);
1024 lstrcatW(buf, L"\\CLSID");
1025 if (open_classes_key(HKEY_CLASSES_ROOT, buf, MAXIMUM_ALLOWED, &xhkey))
1026 {
1027 heap_free(buf);
1028 WARN("couldn't open key for ProgID %s\n", debugstr_w(progid));
1029 return CO_E_CLASSSTRING;
1030 }
1031 heap_free(buf);
1032
1033 if (RegQueryValueW(xhkey, NULL, buf2, &buf2len))
1034 {
1035 RegCloseKey(xhkey);
1036 WARN("couldn't query clsid value for ProgID %s\n", debugstr_w(progid));
1037 return CO_E_CLASSSTRING;
1038 }
1039 RegCloseKey(xhkey);
1040 return guid_from_string(buf2, clsid) ? S_OK : CO_E_CLASSSTRING;
1041 }
1042
1043 /******************************************************************************
1044 * CLSIDFromProgID (combase.@)
1045 */
1046 HRESULT WINAPI DECLSPEC_HOTPATCH CLSIDFromProgID(LPCOLESTR progid, CLSID *clsid)
1047 {
1048 ACTCTX_SECTION_KEYED_DATA data;
1049
1050 if (!progid || !clsid)
1051 return E_INVALIDARG;
1052
1053 data.cbSize = sizeof(data);
1054 if (FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION,
1055 progid, &data))
1056 {
1057 struct progidredirect_data *progiddata = (struct progidredirect_data *)data.lpData;
1058 CLSID *alias = (CLSID *)((BYTE *)data.lpSectionBase + progiddata->clsid_offset);
1059 *clsid = *alias;
1060 return S_OK;
1061 }
1062
1063 return clsid_from_string_reg(progid, clsid);
1064 }
1065
1066 /******************************************************************************
1067 * CLSIDFromProgIDEx (combase.@)
1068 */
1069 HRESULT WINAPI CLSIDFromProgIDEx(LPCOLESTR progid, CLSID *clsid)
1070 {
1071 FIXME("%s, %p: semi-stub\n", debugstr_w(progid), clsid);
1072
1073 return CLSIDFromProgID(progid, clsid);
1074 }
1075
1076 /******************************************************************************
1077 * CLSIDFromString (combase.@)
1078 */
1079 HRESULT WINAPI CLSIDFromString(LPCOLESTR str, LPCLSID clsid)
1080 {
1081 CLSID tmp_id;
1082 HRESULT hr;
1083
1084 if (!clsid)
1085 return E_INVALIDARG;
1086
1087 if (guid_from_string(str, clsid))
1088 return S_OK;
1089
1090 /* It appears a ProgID is also valid */
1091 hr = clsid_from_string_reg(str, &tmp_id);
1092 if (SUCCEEDED(hr))
1093 *clsid = tmp_id;
1094
1095 return hr;
1096 }
1097
1098 /******************************************************************************
1099 * IIDFromString (combase.@)
1100 */
1101 HRESULT WINAPI IIDFromString(LPCOLESTR str, IID *iid)
1102 {
1103 TRACE("%s, %p\n", debugstr_w(str), iid);
1104
1105 if (!str)
1106 {
1107 memset(iid, 0, sizeof(*iid));
1108 return S_OK;
1109 }
1110
1111 /* length mismatch is a special case */
1112 if (lstrlenW(str) + 1 != CHARS_IN_GUID)
1113 return E_INVALIDARG;
1114
1115 if (str[0] != '{')
1116 return CO_E_IIDSTRING;
1117
1118 return guid_from_string(str, iid) ? S_OK : CO_E_IIDSTRING;
1119 }
1120
1121 /******************************************************************************
1122 * StringFromCLSID (combase.@)
1123 */
1124 HRESULT WINAPI StringFromCLSID(REFCLSID clsid, LPOLESTR *str)
1125 {
1126 if (!(*str = CoTaskMemAlloc(CHARS_IN_GUID * sizeof(WCHAR)))) return E_OUTOFMEMORY;
1127 StringFromGUID2(clsid, *str, CHARS_IN_GUID);
1128 return S_OK;
1129 }
1130
1131 /******************************************************************************
1132 * StringFromGUID2 (combase.@)
1133 */
1134 INT WINAPI StringFromGUID2(REFGUID guid, LPOLESTR str, INT cmax)
1135 {
1136 if (!guid || cmax < CHARS_IN_GUID) return 0;
1137 swprintf(str, CHARS_IN_GUID, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", guid->Data1,
1138 guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
1139 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
1140 return CHARS_IN_GUID;
1141 }
1142
1143 static void init_multi_qi(DWORD count, MULTI_QI *mqi, HRESULT hr)
1144 {
1145 ULONG i;
1146
1147 for (i = 0; i < count; i++)
1148 {
1149 mqi[i].pItf = NULL;
1150 mqi[i].hr = hr;
1151 }
1152 }
1153
1154 static HRESULT return_multi_qi(IUnknown *unk, DWORD count, MULTI_QI *mqi, BOOL include_unk)
1155 {
1156 ULONG index = 0, fetched = 0;
1157
1158 if (include_unk)
1159 {
1160 mqi[0].hr = S_OK;
1161 mqi[0].pItf = unk;
1162 index = fetched = 1;
1163 }
1164
1165 for (; index < count; index++)
1166 {
1167 mqi[index].hr = IUnknown_QueryInterface(unk, mqi[index].pIID, (void **)&mqi[index].pItf);
1168 if (mqi[index].hr == S_OK)
1169 fetched++;
1170 }
1171
1172 if (!include_unk)
1173 IUnknown_Release(unk);
1174
1175 if (fetched == 0)
1176 return E_NOINTERFACE;
1177
1178 return fetched == count ? S_OK : CO_S_NOTALLINTERFACES;
1179 }
1180
1181 /***********************************************************************
1182 * CoGetInstanceFromFile (combase.@)
1183 */
1184 HRESULT WINAPI DECLSPEC_HOTPATCH CoGetInstanceFromFile(COSERVERINFO *server_info, CLSID *rclsid,
1185 IUnknown *outer, DWORD cls_context, DWORD grfmode, OLECHAR *filename, DWORD count,
1186 MULTI_QI *results)
1187 {
1188 IPersistFile *pf = NULL;
1189 IUnknown *obj = NULL;
1190 CLSID clsid;
1191 HRESULT hr;
1192
1193 if (!count || !results)
1194 return E_INVALIDARG;
1195
1196 if (server_info)
1197 FIXME("() non-NULL server_info not supported\n");
1198
1199 init_multi_qi(count, results, E_NOINTERFACE);
1200
1201 if (!rclsid)
1202 {
1203 hr = GetClassFile(filename, &clsid);
1204 if (FAILED(hr))
1205 {
1206 ERR("Failed to get CLSID from a file.\n");
1207 return hr;
1208 }
1209
1210 rclsid = &clsid;
1211 }
1212
1213 hr = CoCreateInstance(rclsid, outer, cls_context, &IID_IUnknown, (void **)&obj);
1214 if (hr != S_OK)
1215 {
1216 init_multi_qi(count, results, hr);
1217 return hr;
1218 }
1219
1220 /* Init from file */
1221 hr = IUnknown_QueryInterface(obj, &IID_IPersistFile, (void **)&pf);
1222 if (FAILED(hr))
1223 {
1224 init_multi_qi(count, results, hr);
1225 IUnknown_Release(obj);
1226 return hr;
1227 }
1228
1229 hr = IPersistFile_Load(pf, filename, grfmode);
1230 IPersistFile_Release(pf);
1231 if (SUCCEEDED(hr))
1232 return return_multi_qi(obj, count, results, FALSE);
1233 else
1234 {
1235 init_multi_qi(count, results, hr);
1236 IUnknown_Release(obj);
1237 return hr;
1238 }
1239 }
1240
1241 /***********************************************************************
1242 * CoGetInstanceFromIStorage (combase.@)
1243 */
1244 HRESULT WINAPI CoGetInstanceFromIStorage(COSERVERINFO *server_info, CLSID *rclsid,
1245 IUnknown *outer, DWORD cls_context, IStorage *storage, DWORD count, MULTI_QI *results)
1246 {
1247 IPersistStorage *ps = NULL;
1248 IUnknown *obj = NULL;
1249 STATSTG stat;
1250 HRESULT hr;
1251
1252 if (!count || !results || !storage)
1253 return E_INVALIDARG;
1254
1255 if (server_info)
1256 FIXME("() non-NULL server_info not supported\n");
1257
1258 init_multi_qi(count, results, E_NOINTERFACE);
1259
1260 if (!rclsid)
1261 {
1262 memset(&stat.clsid, 0, sizeof(stat.clsid));
1263 hr = IStorage_Stat(storage, &stat, STATFLAG_NONAME);
1264 if (FAILED(hr))
1265 {
1266 ERR("Failed to get CLSID from a storage.\n");
1267 return hr;
1268 }
1269
1270 rclsid = &stat.clsid;
1271 }
1272
1273 hr = CoCreateInstance(rclsid, outer, cls_context, &IID_IUnknown, (void **)&obj);
1274 if (hr != S_OK)
1275 return hr;
1276
1277 /* Init from IStorage */
1278 hr = IUnknown_QueryInterface(obj, &IID_IPersistStorage, (void **)&ps);
1279 if (FAILED(hr))
1280 ERR("failed to get IPersistStorage\n");
1281
1282 if (ps)
1283 {
1284 IPersistStorage_Load(ps, storage);
1285 IPersistStorage_Release(ps);
1286 }
1287
1288 return return_multi_qi(obj, count, results, FALSE);
1289 }
1290
1291 /***********************************************************************
1292 * CoCreateInstance (combase.@)
1293 */
1294 HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, IUnknown *outer, DWORD cls_context,
1295 REFIID riid, void **obj)
1296 {
1297 MULTI_QI multi_qi = { .pIID = riid };
1298 HRESULT hr;
1299
1300 TRACE("%s, %p, %#x, %s, %p.\n", debugstr_guid(rclsid), outer, cls_context, debugstr_guid(riid), obj);
1301
1302 if (!obj)
1303 return E_POINTER;
1304
1305 hr = CoCreateInstanceEx(rclsid, outer, cls_context, NULL, 1, &multi_qi);
1306 *obj = multi_qi.pItf;
1307 return hr;
1308 }
1309
1310 /***********************************************************************
1311 * CoCreateInstanceEx (combase.@)
1312 */
1313 HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstanceEx(REFCLSID rclsid, IUnknown *outer, DWORD cls_context,
1314 COSERVERINFO *server_info, ULONG count, MULTI_QI *results)
1315 {
1316 IClassFactory *factory;
1317 IUnknown *unk = NULL;
1318 CLSID clsid;
1319 HRESULT hr;
1320
1321 TRACE("%s, %p, %#x, %p, %u, %p\n", debugstr_guid(rclsid), outer, cls_context, server_info, count, results);
1322
1323 if (!count || !results)
1324 return E_INVALIDARG;
1325
1326 if (server_info)
1327 FIXME("Server info is not supported.\n");
1328
1329 init_multi_qi(count, results, E_NOINTERFACE);
1330
1331 hr = CoGetTreatAsClass(rclsid, &clsid);
1332 if (FAILED(hr))
1333 clsid = *rclsid;
1334
1335 hr = CoGetClassObject(&clsid, cls_context, NULL, &IID_IClassFactory, (void **)&factory);
1336 if (FAILED(hr))
1337 return hr;
1338
1339 hr = IClassFactory_CreateInstance(factory, outer, results[0].pIID, (void **)&unk);
1340 IClassFactory_Release(factory);
1341 if (FAILED(hr))
1342 {
1343 if (hr == CLASS_E_NOAGGREGATION && outer)
1344 FIXME("Class %s does not support aggregation\n", debugstr_guid(&clsid));
1345 else
1346 FIXME("no instance created for interface %s of class %s, hr %#x.\n",
1347 debugstr_guid(results[0].pIID), debugstr_guid(&clsid), hr);
1348 return hr;
1349 }
1350
1351 return return_multi_qi(unk, count, results, TRUE);
1352 }
1353
1354 /***********************************************************************
1355 * CoFreeUnusedLibraries (combase.@)
1356 */
1357 void WINAPI DECLSPEC_HOTPATCH CoFreeUnusedLibraries(void)
1358 {
1359 CoFreeUnusedLibrariesEx(INFINITE, 0);
1360 }
Windows API implementation