?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[Mono.Runtime.Tests] Exclude simd tests
[mono-project.git] / mono / metadata / cominterop.c
blob8be260317c039843be609da4b9f744d8c7d27bb5
1 /**
2 * \file
3 * COM Interop Support
4 *
5 *
6 * (C) 2002 Ximian, Inc. http://www.ximian.com
7 *
8 */
9
10 #include "config.h"
11 #include <glib.h>
12 #ifdef HAVE_ALLOCA_H
13 #include <alloca.h>
14 #endif
15
16 #include "object.h"
17 #include "loader.h"
18 #include "cil-coff.h"
19 #include "metadata/abi-details.h"
20 #include "metadata/cominterop.h"
21 #include "metadata/marshal.h"
22 #include "metadata/method-builder.h"
23 #include "metadata/tabledefs.h"
24 #include "metadata/exception.h"
25 #include "metadata/appdomain.h"
26 #include "metadata/reflection-internals.h"
27 #include "mono/metadata/class-init.h"
28 #include "mono/metadata/debug-helpers.h"
29 #include "mono/metadata/threads.h"
30 #include "mono/metadata/monitor.h"
31 #include "mono/metadata/metadata-internals.h"
32 #include "mono/metadata/method-builder-ilgen-internals.h"
33 #include "mono/metadata/domain-internals.h"
34 #include "mono/metadata/gc-internals.h"
35 #include "mono/metadata/threads-types.h"
36 #include "mono/metadata/string-icalls.h"
37 #include "mono/metadata/attrdefs.h"
38 #include "mono/utils/mono-counters.h"
39 #include "mono/utils/strenc.h"
40 #include "mono/utils/atomic.h"
41 #include "mono/utils/mono-error.h"
42 #include "mono/utils/mono-error-internals.h"
43 #include <string.h>
44 #include <errno.h>
45 #include <mono/utils/w32api.h>
46 #if defined (HOST_WIN32)
47 #include <oleauto.h>
48 #include "mono/metadata/cominterop-win32-internals.h"
49 #endif
50 #include "icall-decl.h"
51
52 static void
53 mono_System_ComObject_ReleaseInterfaces (MonoComObjectHandle obj);
54
55 #ifndef DISABLE_COM
56
57 static int
58 mono_IUnknown_QueryInterface (MonoIUnknown *pUnk, gconstpointer riid, gpointer* ppv)
59 {
60 g_assert (pUnk);
61 return pUnk->vtable->QueryInterface (pUnk, riid, ppv);
62 }
63
64 static int
65 mono_IUnknown_AddRef (MonoIUnknown *pUnk)
66 {
67 // The return value is a reference count, generally transient, generally not to be used, except for debugging,
68 // or to assert that it is > 0.
69 g_assert (pUnk);
70 return pUnk->vtable->AddRef (pUnk);
71 }
72
73 static int
74 mono_IUnknown_Release (MonoIUnknown *pUnk)
75 {
76 // Release is like free -- null is silently ignored.
77 // Also, the return value is a reference count, generally transient, generally not to be used, except for debugging.
78 return pUnk ? pUnk->vtable->Release (pUnk) : 0;
79 }
80
81 #endif
82
83 /*
84 Code shared between the DISABLE_COM and !DISABLE_COM
85 */
86 #ifdef __cplusplus
87 template <typename T>
88 static void
89 register_icall ( T func, const char *name, const char *sigstr, gboolean save)
90 #else
91 static void
92 register_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
93 #endif
94 {
95 MonoMethodSignature *sig = mono_create_icall_signature (sigstr);
96
97 mono_register_jit_icall_full (func, name, sig, save, name);
98 }
99
100 mono_bstr
101 mono_string_to_bstr_impl (MonoStringHandle s, MonoError *error)
102 {
103 if (MONO_HANDLE_IS_NULL (s))
104 return NULL;
105
106 gchandle_t gchandle = 0;
107 mono_bstr const res = mono_ptr_to_bstr (mono_string_handle_pin_chars (s, &gchandle), mono_string_handle_length (s));
108 mono_gchandle_free_internal (gchandle);
109 return res;
110 }
111
112 static void*
113 mono_cominterop_get_com_interface_internal (gboolean icall, MonoObjectHandle object, MonoClass *ic, MonoError *error);
114
115 #ifndef DISABLE_COM
116
117 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
118 a = i,
119 typedef enum {
120 MONO_MARSHAL_NONE, /* No marshalling needed */
121 MONO_MARSHAL_COPY, /* Can be copied by value to the new domain */
122 MONO_MARSHAL_COPY_OUT, /* out parameter that needs to be copied back to the original instance */
123 MONO_MARSHAL_SERIALIZE /* Value needs to be serialized into the new domain */
124 } MonoXDomainMarshalType;
125
126 typedef enum {
127 MONO_COM_DEFAULT,
128 MONO_COM_MS
129 } MonoCOMProvider;
130
131 static MonoCOMProvider com_provider = MONO_COM_DEFAULT;
132
133 enum {
134 #include "mono/cil/opcode.def"
135 LAST = 0xff
136 };
137 #undef OPDEF
138
139 /* This mutex protects the various cominterop related caches in MonoImage */
140 #define mono_cominterop_lock() mono_os_mutex_lock (&cominterop_mutex)
141 #define mono_cominterop_unlock() mono_os_mutex_unlock (&cominterop_mutex)
142 static mono_mutex_t cominterop_mutex;
143
144 GENERATE_GET_CLASS_WITH_CACHE (interop_proxy, "Mono.Interop", "ComInteropProxy")
145 GENERATE_GET_CLASS_WITH_CACHE (idispatch, "Mono.Interop", "IDispatch")
146 GENERATE_GET_CLASS_WITH_CACHE (iunknown, "Mono.Interop", "IUnknown")
147
148 GENERATE_GET_CLASS_WITH_CACHE (com_object, "System", "__ComObject")
149 GENERATE_GET_CLASS_WITH_CACHE (variant, "System", "Variant")
150
151 static GENERATE_GET_CLASS_WITH_CACHE (interface_type_attribute, "System.Runtime.InteropServices", "InterfaceTypeAttribute")
152 static GENERATE_GET_CLASS_WITH_CACHE (guid_attribute, "System.Runtime.InteropServices", "GuidAttribute")
153
154 /* Upon creation of a CCW, only allocate a weak handle and set the
155 * reference count to 0. If the unmanaged client code decides to addref and
156 * hold onto the CCW, I then allocate a strong handle. Once the reference count
157 * goes back to 0, convert back to a weak handle.
158 */
159 typedef struct {
160 guint32 ref_count;
161 guint32 gc_handle;
162 GHashTable* vtable_hash;
163 #ifdef HOST_WIN32
164 MonoIUnknown *free_marshaler; // actually IMarshal
165 #endif
166 } MonoCCW;
167
168 /* This type is the actual pointer passed to unmanaged code
169 * to represent a COM interface.
170 */
171 typedef struct {
172 gpointer vtable;
173 MonoCCW* ccw;
174 } MonoCCWInterface;
175
176 /* IUnknown */
177 static int STDCALL cominterop_ccw_addref (MonoCCWInterface* ccwe);
178
179 static int STDCALL cominterop_ccw_release (MonoCCWInterface* ccwe);
180
181 static int STDCALL cominterop_ccw_queryinterface (MonoCCWInterface* ccwe, const guint8* riid, gpointer* ppv);
182
183 /* IDispatch */
184 static int STDCALL cominterop_ccw_get_type_info_count (MonoCCWInterface* ccwe, guint32 *pctinfo);
185
186 static int STDCALL cominterop_ccw_get_type_info (MonoCCWInterface* ccwe, guint32 iTInfo, guint32 lcid, gpointer *ppTInfo);
187
188 static int STDCALL cominterop_ccw_get_ids_of_names (MonoCCWInterface* ccwe, gpointer riid,
189 gunichar2** rgszNames, guint32 cNames,
190 guint32 lcid, gint32 *rgDispId);
191
192 static int STDCALL cominterop_ccw_invoke (MonoCCWInterface* ccwe, guint32 dispIdMember,
193 gpointer riid, guint32 lcid,
194 guint16 wFlags, gpointer pDispParams,
195 gpointer pVarResult, gpointer pExcepInfo,
196 guint32 *puArgErr);
197
198 static MonoMethod *
199 cominterop_get_managed_wrapper_adjusted (MonoMethod *method);
200
201 static gpointer
202 cominterop_get_ccw (MonoObject* object, MonoClass* itf);
203
204 static gpointer
205 cominterop_get_ccw_checked (MonoObjectHandle object, MonoClass *itf, MonoError *error);
206
207 static MonoObject*
208 cominterop_get_ccw_object (MonoCCWInterface* ccw_entry, gboolean verify);
209
210 static MonoObjectHandle
211 cominterop_get_ccw_handle (MonoCCWInterface* ccw_entry, gboolean verify);
212
213 /* SAFEARRAY marshalling */
214 static gboolean
215 mono_marshal_safearray_begin (gpointer safearray, MonoArray **result, gpointer *indices, gpointer empty, gpointer parameter, gboolean allocateNewArray);
216
217 static gpointer
218 mono_marshal_safearray_get_value (gpointer safearray, gpointer indices);
219
220 static gboolean
221 mono_marshal_safearray_next (gpointer safearray, gpointer indices);
222
223 static void
224 mono_marshal_safearray_end (gpointer safearray, gpointer indices);
225
226 static gboolean
227 mono_marshal_safearray_create (MonoArray *input, gpointer *newsafearray, gpointer *indices, gpointer empty);
228
229 static void
230 mono_marshal_safearray_set_value (gpointer safearray, gpointer indices, gpointer value);
231
232 static void
233 mono_marshal_safearray_free_indices (gpointer indices);
234
235 MonoClass*
236 mono_class_try_get_com_object_class (void)
237 {
238 static MonoClass *tmp_class;
239 static gboolean inited;
240 MonoClass *klass;
241 if (!inited) {
242 klass = mono_class_load_from_name (mono_defaults.corlib, "System", "__ComObject");
243 mono_memory_barrier ();
244 tmp_class = klass;
245 mono_memory_barrier ();
246 inited = TRUE;
247 }
248 return tmp_class;
249 }
250
251 /**
252 * cominterop_method_signature:
253 * @method: a method
254 *
255 * Returns: the corresponding unmanaged method signature for a managed COM
256 * method.
257 */
258 static MonoMethodSignature*
259 cominterop_method_signature (MonoMethod* method)
260 {
261 MonoMethodSignature *res;
262 MonoImage *image = m_class_get_image (method->klass);
263 MonoMethodSignature *sig = mono_method_signature_internal (method);
264 gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
265 int sigsize;
266 int i;
267 int param_count = sig->param_count + 1; // convert this arg into IntPtr arg
268
269 if (!preserve_sig &&!MONO_TYPE_IS_VOID (sig->ret))
270 param_count++;
271
272 res = mono_metadata_signature_alloc (image, param_count);
273 sigsize = MONO_SIZEOF_METHOD_SIGNATURE + sig->param_count * sizeof (MonoType *);
274 memcpy (res, sig, sigsize);
275
276 // now move args forward one
277 for (i = sig->param_count-1; i >= 0; i--)
278 res->params[i+1] = sig->params[i];
279
280 // first arg is interface pointer
281 res->params[0] = mono_get_int_type ();
282
283 if (preserve_sig) {
284 res->ret = sig->ret;
285 }
286 else {
287 // last arg is return type
288 if (!MONO_TYPE_IS_VOID (sig->ret)) {
289 res->params[param_count-1] = mono_metadata_type_dup (image, sig->ret);
290 res->params[param_count-1]->byref = 1;
291 res->params[param_count-1]->attrs = PARAM_ATTRIBUTE_OUT;
292 }
293
294 // return type is always int32 (HRESULT)
295 res->ret = mono_get_int32_type ();
296 }
297
298 // no pinvoke
299 res->pinvoke = FALSE;
300
301 // no hasthis
302 res->hasthis = 0;
303
304 // set param_count
305 res->param_count = param_count;
306
307 // STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM
308 #ifdef HOST_WIN32
309 res->call_convention = MONO_CALL_STDCALL;
310 #else
311 res->call_convention = MONO_CALL_C;
312 #endif
313
314 return res;
315 }
316
317 /**
318 * cominterop_get_function_pointer:
319 * @itf: a pointer to the COM interface
320 * @slot: the vtable slot of the method pointer to return
321 *
322 * Returns: the unmanaged vtable function pointer from the interface
323 */
324 static gpointer
325 cominterop_get_function_pointer (gpointer itf, int slot)
326 {
327 gpointer func;
328 func = *((*(gpointer**)itf)+slot);
329 return func;
330 }
331
332 /**
333 * cominterop_object_is_com_object:
334 * @obj: a pointer to the object
335 *
336 * Returns: a value indicating if the object is a
337 * Runtime Callable Wrapper (RCW) for a COM object
338 */
339 static gboolean
340 cominterop_object_is_rcw_handle (MonoObjectHandle obj, MonoRealProxyHandle *real_proxy)
341 {
342 MonoClass *klass;
343
344 return !MONO_HANDLE_IS_NULL (obj)
345 && (klass = mono_handle_class (obj))
346 && mono_class_is_transparent_proxy (klass)
347 && !MONO_HANDLE_IS_NULL (*real_proxy = MONO_HANDLE_NEW_GET (MonoRealProxy, MONO_HANDLE_CAST (MonoTransparentProxy, obj), rp))
348 && (klass = mono_handle_class (*real_proxy))
349 && klass == mono_class_get_interop_proxy_class ();
350 }
351
352 static gboolean
353 cominterop_object_is_rcw (MonoObject *obj_raw)
354 {
355 if (!obj_raw)
356 return FALSE;
357 HANDLE_FUNCTION_ENTER ();
358 MONO_HANDLE_DCL (MonoObject, obj);
359 MonoRealProxyHandle real_proxy;
360 HANDLE_FUNCTION_RETURN_VAL (cominterop_object_is_rcw_handle (obj, &real_proxy));
361 }
362
363 static int
364 cominterop_get_com_slot_begin (MonoClass* klass)
365 {
366 ERROR_DECL (error);
367 MonoCustomAttrInfo *cinfo = NULL;
368 MonoInterfaceTypeAttribute* itf_attr = NULL;
369
370 cinfo = mono_custom_attrs_from_class_checked (klass, error);
371 mono_error_assert_ok (error);
372 if (cinfo) {
373 itf_attr = (MonoInterfaceTypeAttribute*)mono_custom_attrs_get_attr_checked (cinfo, mono_class_get_interface_type_attribute_class (), error);
374 mono_error_assert_ok (error); /*FIXME proper error handling*/
375 if (!cinfo->cached)
376 mono_custom_attrs_free (cinfo);
377 }
378
379 if (itf_attr && itf_attr->intType == 1)
380 return 3; /* 3 methods in IUnknown*/
381 else
382 return 7; /* 7 methods in IDispatch*/
383 }
384
385 /**
386 * cominterop_get_method_interface:
387 * @method: method being called
388 *
389 * Returns: the MonoClass* representing the interface on which
390 * the method is defined.
391 */
392 static MonoClass*
393 cominterop_get_method_interface (MonoMethod* method)
394 {
395 ERROR_DECL (error);
396 MonoClass *ic = method->klass;
397
398 /* if method is on a class, we need to look up interface method exists on */
399 if (!MONO_CLASS_IS_INTERFACE_INTERNAL (method->klass)) {
400 GPtrArray *ifaces = mono_class_get_implemented_interfaces (method->klass, error);
401 mono_error_assert_ok (error);
402 if (ifaces) {
403 int i;
404 mono_class_setup_vtable (method->klass);
405 for (i = 0; i < ifaces->len; ++i) {
406 int j, offset;
407 gboolean found = FALSE;
408 ic = (MonoClass *)g_ptr_array_index (ifaces, i);
409 offset = mono_class_interface_offset (method->klass, ic);
410 int mcount = mono_class_get_method_count (ic);
411 MonoMethod **method_klass_vtable = m_class_get_vtable (method->klass);
412 for (j = 0; j < mcount; ++j) {
413 if (method_klass_vtable [j + offset] == method) {
414 found = TRUE;
415 break;
416 }
417 }
418 if (found)
419 break;
420 ic = NULL;
421 }
422 g_ptr_array_free (ifaces, TRUE);
423 }
424 }
425
426 return ic;
427 }
428
429 static void
430 mono_cominterop_get_interface_missing_error (MonoError* error, MonoMethod* method)
431 {
432 mono_error_set_invalid_operation (error, "Method '%s' in ComImport class '%s' must implement an interface method.", method->name, m_class_get_name (method->klass));
433 }
434
435 /**
436 * cominterop_get_com_slot_for_method:
437 * @method: a method
438 * @error: set on error
439 *
440 * Returns: the method's slot in the COM interface vtable
441 */
442 static int
443 cominterop_get_com_slot_for_method (MonoMethod* method, MonoError* error)
444 {
445 guint32 slot = method->slot;
446 MonoClass *ic = method->klass;
447
448 error_init (error);
449
450 /* if method is on a class, we need to look up interface method exists on */
451 if (!MONO_CLASS_IS_INTERFACE_INTERNAL (ic)) {
452 int offset = 0;
453 int i = 0;
454 ic = cominterop_get_method_interface (method);
455 if (!ic || !MONO_CLASS_IS_INTERFACE_INTERNAL (ic)) {
456 mono_cominterop_get_interface_missing_error (error, method);
457 return -1;
458 }
459 offset = mono_class_interface_offset (method->klass, ic);
460 g_assert(offset >= 0);
461 int mcount = mono_class_get_method_count (ic);
462 MonoMethod **ic_methods = m_class_get_methods (ic);
463 MonoMethod **method_klass_vtable = m_class_get_vtable (method->klass);
464 for(i = 0; i < mcount; ++i) {
465 if (method_klass_vtable [i + offset] == method)
466 {
467 slot = ic_methods[i]->slot;
468 break;
469 }
470 }
471 }
472
473 g_assert (ic);
474 g_assert (MONO_CLASS_IS_INTERFACE_INTERNAL (ic));
475
476 return slot + cominterop_get_com_slot_begin (ic);
477 }
478
479 static void
480 cominterop_mono_string_to_guid (MonoString* string, guint8 *guid);
481
482 static gboolean
483 cominterop_class_guid (MonoClass* klass, guint8* guid)
484 {
485 ERROR_DECL (error);
486 MonoCustomAttrInfo *cinfo;
487
488 cinfo = mono_custom_attrs_from_class_checked (klass, error);
489 mono_error_assert_ok (error);
490 if (cinfo) {
491 MonoReflectionGuidAttribute *attr = (MonoReflectionGuidAttribute*)mono_custom_attrs_get_attr_checked (cinfo, mono_class_get_guid_attribute_class (), error);
492 mono_error_assert_ok (error); /*FIXME proper error handling*/
493
494 if (!attr)
495 return FALSE;
496 if (!cinfo->cached)
497 mono_custom_attrs_free (cinfo);
498
499 cominterop_mono_string_to_guid (attr->guid, guid);
500 return TRUE;
501 }
502 return FALSE;
503 }
504
505 static gboolean
506 cominterop_com_visible (MonoClass* klass)
507 {
508 ERROR_DECL (error);
509 MonoCustomAttrInfo *cinfo;
510 GPtrArray *ifaces;
511 MonoBoolean visible = 1;
512
513 cinfo = mono_custom_attrs_from_class_checked (klass, error);
514 mono_error_assert_ok (error);
515 if (cinfo) {
516 MonoReflectionComVisibleAttribute *attr = (MonoReflectionComVisibleAttribute*)mono_custom_attrs_get_attr_checked (cinfo, mono_class_get_guid_attribute_class (), error);
517 mono_error_assert_ok (error); /*FIXME proper error handling*/
518
519 if (attr)
520 visible = attr->visible;
521 if (!cinfo->cached)
522 mono_custom_attrs_free (cinfo);
523 if (visible)
524 return TRUE;
525 }
526
527 ifaces = mono_class_get_implemented_interfaces (klass, error);
528 mono_error_assert_ok (error);
529 if (ifaces) {
530 int i;
531 for (i = 0; i < ifaces->len; ++i) {
532 MonoClass *ic = NULL;
533 ic = (MonoClass *)g_ptr_array_index (ifaces, i);
534 if (MONO_CLASS_IS_IMPORT (ic))
535 visible = TRUE;
536
537 }
538 g_ptr_array_free (ifaces, TRUE);
539 }
540 return visible;
541
542 }
543
544 static void
545 cominterop_set_hr_error (MonoError *oerror, int hr)
546 {
547 static MonoMethod* throw_exception_for_hr = NULL;
548 ERROR_DECL (error);
549 MonoException* ex;
550 void* params[1] = {&hr};
551
552 if (!throw_exception_for_hr) {
553 throw_exception_for_hr = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetExceptionForHR", 1, 0, error);
554 mono_error_assert_ok (error);
555 }
556
557 ex = (MonoException*)mono_runtime_invoke_checked (throw_exception_for_hr, NULL, params, error);
558 g_assert (ex);
559 mono_error_assert_ok (error);
560
561 mono_error_set_exception_instance (oerror, ex);
562 }
563
564 /**
565 * cominterop_get_interface_checked:
566 * @obj: managed wrapper object containing COM object
567 * @ic: interface type to retrieve for COM object
568 * @error: set on error
569 *
570 * Returns: the COM interface requested. On failure returns NULL and sets @error
571 */
572 static gpointer
573 cominterop_get_interface_checked (MonoComObjectHandle obj, MonoClass* ic, MonoError *error)
574 {
575 gpointer itf = NULL;
576
577 g_assert (ic);
578 g_assert (MONO_CLASS_IS_INTERFACE_INTERNAL (ic));
579
580 error_init (error);
581
582 mono_cominterop_lock ();
583 if (MONO_HANDLE_GETVAL (obj, itf_hash))
584 itf = g_hash_table_lookup (MONO_HANDLE_GETVAL (obj, itf_hash), GUINT_TO_POINTER ((guint)m_class_get_interface_id (ic)));
585 mono_cominterop_unlock ();
586
587 if (itf)
588 return itf;
589
590 guint8 iid [16];
591 gboolean const found = cominterop_class_guid (ic, iid);
592 g_assert (found);
593 g_assert (MONO_HANDLE_GETVAL (obj, iunknown));
594 int const hr = mono_IUnknown_QueryInterface (MONO_HANDLE_GETVAL (obj, iunknown), iid, &itf);
595 if (hr < 0) {
596 g_assert (!itf);
597 cominterop_set_hr_error (error, hr);
598 g_assert (!mono_error_ok (error));
599 return NULL;
600 }
601
602 g_assert (itf);
603 mono_cominterop_lock ();
604 if (!MONO_HANDLE_GETVAL (obj, itf_hash))
605 MONO_HANDLE_SETVAL (obj, itf_hash, GHashTable*, g_hash_table_new (mono_aligned_addr_hash, NULL));
606 g_hash_table_insert (MONO_HANDLE_GETVAL (obj, itf_hash), GUINT_TO_POINTER ((guint)m_class_get_interface_id (ic)), itf);
607 mono_cominterop_unlock ();
608
609 return itf;
610 }
611
612 /**
613 * cominterop_get_interface:
614 * @obj: managed wrapper object containing COM object
615 * @ic: interface type to retrieve for COM object
616 *
617 * Returns: the COM interface requested
618 */
619 static gpointer
620 cominterop_get_interface (MonoComObject *obj_raw, MonoClass *ic)
621 {
622 HANDLE_FUNCTION_ENTER ();
623 ERROR_DECL (error);
624 MONO_HANDLE_DCL (MonoComObject, obj);
625 gpointer const itf = cominterop_get_interface_checked (obj, ic, error);
626 g_assert (!!itf == is_ok (error)); // two equal success indicators
627 mono_error_set_pending_exception (error);
628 return itf;
629 HANDLE_FUNCTION_RETURN_VAL (itf);
630 }
631
632 // This is an icall, it will return NULL and set pending exception (in
633 // mono_type_from_handle wrapper) on failure.
634 static MonoReflectionType *
635 cominterop_type_from_handle (MonoType *handle)
636 {
637 return mono_type_from_handle (handle);
638 }
639
640 #endif // DISABLE_COM
641
642 void
643 mono_cominterop_init (void)
644 {
645 #ifndef DISABLE_COM
646 mono_os_mutex_init_recursive (&cominterop_mutex);
647
648 char* const com_provider_env = g_getenv ("MONO_COM");
649 if (com_provider_env && !strcmp(com_provider_env, "MS"))
650 com_provider = MONO_COM_MS;
651 g_free (com_provider_env);
652
653 register_icall (cominterop_get_method_interface, "cominterop_get_method_interface", "ptr ptr", FALSE);
654 register_icall (cominterop_get_function_pointer, "cominterop_get_function_pointer", "ptr ptr int32", FALSE);
655 register_icall (cominterop_object_is_rcw, "cominterop_object_is_rcw", "int32 object", FALSE);
656 register_icall (cominterop_get_ccw, "cominterop_get_ccw", "ptr object ptr", FALSE);
657 register_icall (cominterop_get_ccw_object, "cominterop_get_ccw_object", "object ptr int32", FALSE);
658 register_icall (cominterop_get_interface, "cominterop_get_interface", "ptr object ptr", FALSE);
659
660 register_icall (cominterop_type_from_handle, "cominterop_type_from_handle", "object ptr", FALSE);
661
662 /* SAFEARRAY marshalling */
663 register_icall (mono_marshal_safearray_begin, "mono_marshal_safearray_begin", "int32 ptr ptr ptr ptr ptr int32", FALSE);
664 register_icall (mono_marshal_safearray_get_value, "mono_marshal_safearray_get_value", "ptr ptr ptr", FALSE);
665 register_icall (mono_marshal_safearray_next, "mono_marshal_safearray_next", "int32 ptr ptr", FALSE);
666 register_icall (mono_marshal_safearray_end, "mono_marshal_safearray_end", "void ptr ptr", FALSE);
667 register_icall (mono_marshal_safearray_create, "mono_marshal_safearray_create", "int32 object ptr ptr ptr", FALSE);
668 register_icall (mono_marshal_safearray_set_value, "mono_marshal_safearray_set_value", "void ptr ptr ptr", FALSE);
669 register_icall (mono_marshal_safearray_free_indices, "mono_marshal_safearray_free_indices", "void ptr", FALSE);
670 #endif // DISABLE_COM
671 /*FIXME
672
673 This icalls are used by the marshal code when doing PtrToStructure and StructureToPtr and pinvoke.
674
675 If we leave them out and the FullAOT compiler finds the need to emit one of the above 3 wrappers it will
676 g_assert.
677
678 The proper fix would be to emit warning, remove them from marshal.c when DISABLE_COM is used and
679 emit an exception in the generated IL.
680 */
681 register_icall (mono_string_to_bstr, "mono_string_to_bstr", "ptr obj", FALSE);
682 register_icall (mono_string_from_bstr_icall, "mono_string_from_bstr_icall", "obj ptr", FALSE);
683 register_icall (mono_free_bstr, "mono_free_bstr", "void ptr", FALSE);
684 }
685
686 #ifndef DISABLE_COM
687
688 void
689 mono_cominterop_cleanup (void)
690 {
691 mono_os_mutex_destroy (&cominterop_mutex);
692 }
693
694 void
695 mono_mb_emit_cominterop_get_function_pointer (MonoMethodBuilder *mb, MonoMethod *method)
696 {
697 #ifndef DISABLE_JIT
698 int slot;
699 ERROR_DECL (error);
700 // get function pointer from 1st arg, the COM interface pointer
701 mono_mb_emit_ldarg (mb, 0);
702 slot = cominterop_get_com_slot_for_method (method, error);
703 if (is_ok (error)) {
704 mono_mb_emit_icon (mb, slot);
705 mono_mb_emit_icall (mb, cominterop_get_function_pointer);
706 /* Leaves the function pointer on top of the stack */
707 }
708 else {
709 mono_mb_emit_exception_for_error (mb, error);
710 }
711 mono_error_cleanup (error);
712 #endif
713 }
714
715 void
716 mono_mb_emit_cominterop_call_function_pointer (MonoMethodBuilder *mb, MonoMethodSignature *sig)
717 {
718 #ifndef DISABLE_JIT
719 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
720 mono_mb_emit_byte (mb, CEE_MONO_SAVE_LMF);
721 mono_mb_emit_calli (mb, sig);
722 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
723 mono_mb_emit_byte (mb, CEE_MONO_RESTORE_LMF);
724 #endif /* DISABLE_JIT */
725 }
726
727 void
728 mono_mb_emit_cominterop_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethod* method)
729 {
730 #ifndef DISABLE_JIT
731 mono_mb_emit_cominterop_get_function_pointer (mb, method);
732
733 mono_mb_emit_cominterop_call_function_pointer (mb, sig);
734 #endif /* DISABLE_JIT */
735 }
736
737 void
738 mono_cominterop_emit_ptr_to_object_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec)
739 {
740 #ifndef DISABLE_JIT
741 switch (conv) {
742 case MONO_MARSHAL_CONV_OBJECT_INTERFACE:
743 case MONO_MARSHAL_CONV_OBJECT_IUNKNOWN:
744 case MONO_MARSHAL_CONV_OBJECT_IDISPATCH: {
745 static MonoMethod* com_interop_proxy_get_proxy = NULL;
746 static MonoMethod* get_transparent_proxy = NULL;
747 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
748 MonoClass *klass = NULL;
749
750 klass = mono_class_from_mono_type_internal (type);
751
752 mono_mb_emit_ldloc (mb, 1);
753 mono_mb_emit_byte (mb, CEE_LDNULL);
754 mono_mb_emit_byte (mb, CEE_STIND_REF);
755
756 mono_mb_emit_ldloc (mb, 0);
757 mono_mb_emit_byte (mb, CEE_LDIND_I);
758 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
759
760 /* load dst to store later */
761 mono_mb_emit_ldloc (mb, 1);
762
763 mono_mb_emit_ldloc (mb, 0);
764 mono_mb_emit_byte (mb, CEE_LDIND_I);
765 mono_mb_emit_icon (mb, TRUE);
766 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
767 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
768
769 if (!com_interop_proxy_get_proxy) {
770 ERROR_DECL (error);
771 com_interop_proxy_get_proxy = mono_class_get_method_from_name_checked (mono_class_get_interop_proxy_class (), "GetProxy", 2, METHOD_ATTRIBUTE_PRIVATE, error);
772 mono_error_assert_ok (error);
773 }
774 #ifndef DISABLE_REMOTING
775 if (!get_transparent_proxy) {
776 ERROR_DECL (error);
777 get_transparent_proxy = mono_class_get_method_from_name_checked (mono_defaults.real_proxy_class, "GetTransparentProxy", 0, 0, error);
778 mono_error_assert_ok (error);
779 }
780 #endif
781
782 mono_mb_add_local (mb, m_class_get_byval_arg (mono_class_get_interop_proxy_class ()));
783
784 mono_mb_emit_ldloc (mb, 0);
785 mono_mb_emit_byte (mb, CEE_LDIND_I);
786 mono_mb_emit_ptr (mb, m_class_get_byval_arg (mono_class_get_com_object_class ()));
787 mono_mb_emit_icall (mb, cominterop_type_from_handle);
788 mono_mb_emit_managed_call (mb, com_interop_proxy_get_proxy, NULL);
789 mono_mb_emit_managed_call (mb, get_transparent_proxy, NULL);
790 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
791 g_assert (klass);
792 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
793 }
794 mono_mb_emit_byte (mb, CEE_STIND_REF);
795 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
796
797 /* is already managed object */
798 mono_mb_patch_short_branch (mb, pos_ccw);
799 mono_mb_emit_ldloc (mb, 0);
800 mono_mb_emit_byte (mb, CEE_LDIND_I);
801 mono_mb_emit_icon (mb, TRUE);
802 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
803
804 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
805 g_assert (klass);
806 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
807 }
808 mono_mb_emit_byte (mb, CEE_STIND_REF);
809
810 mono_mb_patch_short_branch (mb, pos_end);
811 /* case if null */
812 mono_mb_patch_short_branch (mb, pos_null);
813 break;
814 }
815 default:
816 g_assert_not_reached ();
817 }
818 #endif /* DISABLE_JIT */
819 }
820
821 void
822 mono_cominterop_emit_object_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec)
823 {
824 #ifndef DISABLE_JIT
825 switch (conv) {
826 case MONO_MARSHAL_CONV_OBJECT_INTERFACE:
827 case MONO_MARSHAL_CONV_OBJECT_IDISPATCH:
828 case MONO_MARSHAL_CONV_OBJECT_IUNKNOWN: {
829 guint32 pos_null = 0, pos_rcw = 0, pos_end = 0;
830
831 mono_mb_emit_ldloc (mb, 1);
832 mono_mb_emit_icon (mb, 0);
833 mono_mb_emit_byte (mb, CEE_CONV_U);
834 mono_mb_emit_byte (mb, CEE_STIND_I);
835
836 mono_mb_emit_ldloc (mb, 0);
837 mono_mb_emit_byte (mb, CEE_LDIND_REF);
838
839 // if null just break, dst was already inited to 0
840 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
841
842 mono_mb_emit_ldloc (mb, 0);
843 mono_mb_emit_byte (mb, CEE_LDIND_REF);
844 mono_mb_emit_icall (mb, cominterop_object_is_rcw);
845 pos_rcw = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
846
847 // load dst to store later
848 mono_mb_emit_ldloc (mb, 1);
849
850 // load src
851 mono_mb_emit_ldloc (mb, 0);
852 mono_mb_emit_byte (mb, CEE_LDIND_REF);
853 mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoTransparentProxy, rp));
854 mono_mb_emit_byte (mb, CEE_LDIND_REF);
855
856 /* load the RCW from the ComInteropProxy*/
857 mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoComInteropProxy, com_object));
858 mono_mb_emit_byte (mb, CEE_LDIND_REF);
859
860 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE) {
861 mono_mb_emit_ptr (mb, mono_type_get_class (type));
862 mono_mb_emit_icall (mb, cominterop_get_interface);
863
864 }
865 else if (conv == MONO_MARSHAL_CONV_OBJECT_IUNKNOWN) {
866 static MonoProperty* iunknown = NULL;
867
868 if (!iunknown)
869 iunknown = mono_class_get_property_from_name (mono_class_get_com_object_class (), "IUnknown");
870 mono_mb_emit_managed_call (mb, iunknown->get, NULL);
871 }
872 else if (conv == MONO_MARSHAL_CONV_OBJECT_IDISPATCH) {
873 static MonoProperty* idispatch = NULL;
874
875 if (!idispatch)
876 idispatch = mono_class_get_property_from_name (mono_class_get_com_object_class (), "IDispatch");
877 mono_mb_emit_managed_call (mb, idispatch->get, NULL);
878 }
879 else {
880 g_assert_not_reached ();
881 }
882 mono_mb_emit_byte (mb, CEE_STIND_I);
883 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
884
885 // if not rcw
886 mono_mb_patch_short_branch (mb, pos_rcw);
887 /* load dst to store later */
888 mono_mb_emit_ldloc (mb, 1);
889 /* load src */
890 mono_mb_emit_ldloc (mb, 0);
891 mono_mb_emit_byte (mb, CEE_LDIND_REF);
892
893 if (conv == MONO_MARSHAL_CONV_OBJECT_INTERFACE)
894 mono_mb_emit_ptr (mb, mono_type_get_class (type));
895 else if (conv == MONO_MARSHAL_CONV_OBJECT_IUNKNOWN)
896 mono_mb_emit_ptr (mb, mono_class_get_iunknown_class ());
897 else if (conv == MONO_MARSHAL_CONV_OBJECT_IDISPATCH)
898 mono_mb_emit_ptr (mb, mono_class_get_idispatch_class ());
899 else
900 g_assert_not_reached ();
901 mono_mb_emit_icall (mb, cominterop_get_ccw);
902 mono_mb_emit_byte (mb, CEE_STIND_I);
903
904 mono_mb_patch_short_branch (mb, pos_end);
905 mono_mb_patch_short_branch (mb, pos_null);
906 break;
907 }
908 default:
909 g_assert_not_reached ();
910 }
911 #endif /* DISABLE_JIT */
912 }
913
914 /**
915 * cominterop_get_native_wrapper_adjusted:
916 * @method: managed COM Interop method
917 *
918 * Returns: the generated method to call with signature matching
919 * the unmanaged COM Method signature
920 */
921 static MonoMethod *
922 cominterop_get_native_wrapper_adjusted (MonoMethod *method)
923 {
924 MonoMethod *res;
925 MonoMethodBuilder *mb_native;
926 MonoMarshalSpec **mspecs;
927 MonoMethodSignature *sig, *sig_native;
928 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *) method;
929 int i;
930
931 sig = mono_method_signature_internal (method);
932
933 // create unmanaged wrapper
934 mb_native = mono_mb_new (method->klass, method->name, MONO_WRAPPER_MANAGED_TO_NATIVE);
935 sig_native = cominterop_method_signature (method);
936
937 mspecs = g_new0 (MonoMarshalSpec*, sig_native->param_count + 1);
938
939 mono_method_get_marshal_info (method, mspecs);
940
941 // move managed args up one
942 for (i = sig->param_count; i >= 1; i--)
943 mspecs[i+1] = mspecs[i];
944
945 // first arg is IntPtr for interface
946 mspecs[1] = NULL;
947
948 if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG)) {
949 // move return spec to last param
950 if (!MONO_TYPE_IS_VOID (sig->ret))
951 mspecs[sig_native->param_count] = mspecs[0];
952
953 mspecs[0] = NULL;
954 }
955
956 for (i = 1; i < sig_native->param_count; i++) {
957 int mspec_index = i + 1;
958 if (mspecs[mspec_index] == NULL) {
959 // default object to VARIANT
960 if (sig_native->params[i]->type == MONO_TYPE_OBJECT) {
961 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
962 mspecs[mspec_index]->native = MONO_NATIVE_STRUCT;
963 }
964 else if (sig_native->params[i]->type == MONO_TYPE_STRING) {
965 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
966 mspecs[mspec_index]->native = MONO_NATIVE_BSTR;
967 }
968 else if (sig_native->params[i]->type == MONO_TYPE_CLASS) {
969 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
970 mspecs[mspec_index]->native = MONO_NATIVE_INTERFACE;
971 }
972 else if (sig_native->params[i]->type == MONO_TYPE_BOOLEAN) {
973 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
974 mspecs[mspec_index]->native = MONO_NATIVE_VARIANTBOOL;
975 }
976 }
977 }
978
979 if (method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG) {
980 // move return spec to last param
981 if (!MONO_TYPE_IS_VOID (sig->ret) && mspecs[0] == NULL) {
982 // default object to VARIANT
983 if (sig->ret->type == MONO_TYPE_OBJECT) {
984 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
985 mspecs[0]->native = MONO_NATIVE_STRUCT;
986 }
987 else if (sig->ret->type == MONO_TYPE_STRING) {
988 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
989 mspecs[0]->native = MONO_NATIVE_BSTR;
990 }
991 else if (sig->ret->type == MONO_TYPE_CLASS) {
992 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
993 mspecs[0]->native = MONO_NATIVE_INTERFACE;
994 }
995 else if (sig->ret->type == MONO_TYPE_BOOLEAN) {
996 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
997 mspecs[0]->native = MONO_NATIVE_VARIANTBOOL;
998 }
999 }
1000 }
1001
1002 mono_marshal_emit_native_wrapper (m_class_get_image (method->klass), mb_native, sig_native, piinfo, mspecs, piinfo->addr, FALSE, TRUE, FALSE);
1003
1004 res = mono_mb_create_method (mb_native, sig_native, sig_native->param_count + 16);
1005
1006 mono_mb_free (mb_native);
1007
1008 for (i = sig_native->param_count; i >= 0; i--)
1009 if (mspecs [i])
1010 mono_metadata_free_marshal_spec (mspecs [i]);
1011 g_free (mspecs);
1012
1013 return res;
1014 }
1015
1016 /**
1017 * mono_cominterop_get_native_wrapper:
1018 * \param method managed method
1019 * \returns the generated method to call
1020 */
1021 MonoMethod *
1022 mono_cominterop_get_native_wrapper (MonoMethod *method)
1023 {
1024 MonoMethod *res;
1025 GHashTable *cache;
1026 MonoMethodBuilder *mb;
1027 MonoMethodSignature *sig, *csig;
1028
1029 g_assert (method);
1030
1031 cache = mono_marshal_get_cache (&mono_method_get_wrapper_cache (method)->cominterop_wrapper_cache, mono_aligned_addr_hash, NULL);
1032
1033 if ((res = mono_marshal_find_in_cache (cache, method)))
1034 return res;
1035
1036 if (!m_class_get_vtable (method->klass))
1037 mono_class_setup_vtable (method->klass);
1038
1039 if (!m_class_get_methods (method->klass))
1040 mono_class_setup_methods (method->klass);
1041 g_assert (!mono_class_has_failure (method->klass)); /*FIXME do proper error handling*/
1042
1043 sig = mono_method_signature_internal (method);
1044 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP);
1045
1046 #ifndef DISABLE_JIT
1047 /* if method klass is import, that means method
1048 * is really a com call. let interop system emit it.
1049 */
1050 if (MONO_CLASS_IS_IMPORT(method->klass)) {
1051 /* FIXME: we have to call actual class .ctor
1052 * instead of just __ComObject .ctor.
1053 */
1054 if (!strcmp(method->name, ".ctor")) {
1055 static MonoMethod *ctor = NULL;
1056
1057 if (!ctor) {
1058 ERROR_DECL (error);
1059 ctor = mono_class_get_method_from_name_checked (mono_class_get_com_object_class (), ".ctor", 0, 0, error);
1060 mono_error_assert_ok (error);
1061 }
1062 mono_mb_emit_ldarg (mb, 0);
1063 mono_mb_emit_managed_call (mb, ctor, NULL);
1064 mono_mb_emit_byte (mb, CEE_RET);
1065 }
1066 else if (method->flags & METHOD_ATTRIBUTE_STATIC) {
1067 /*
1068 * The method's class must implement an interface.
1069 * However, no interfaces are allowed to have static methods.
1070 * Thus, calling it should invariably lead to an exception.
1071 */
1072 ERROR_DECL (error);
1073 mono_cominterop_get_interface_missing_error (error, method);
1074 mono_mb_emit_exception_for_error (mb, error);
1075 mono_error_cleanup (error);
1076 }
1077 else {
1078 static MonoMethod * ThrowExceptionForHR = NULL;
1079 MonoMethod *adjusted_method;
1080 int retval = 0;
1081 int ptr_this;
1082 int i;
1083 gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
1084
1085 // add local variables
1086 ptr_this = mono_mb_add_local (mb, mono_get_int_type ());
1087 if (!MONO_TYPE_IS_VOID (sig->ret))
1088 retval = mono_mb_add_local (mb, sig->ret);
1089
1090 // get the type for the interface the method is defined on
1091 // and then get the underlying COM interface for that type
1092 mono_mb_emit_ldarg (mb, 0);
1093 mono_mb_emit_ptr (mb, method);
1094 mono_mb_emit_icall (mb, cominterop_get_method_interface);
1095 mono_mb_emit_icall (mb, cominterop_get_interface);
1096 mono_mb_emit_stloc (mb, ptr_this);
1097
1098 // arg 1 is unmanaged this pointer
1099 mono_mb_emit_ldloc (mb, ptr_this);
1100
1101 // load args
1102 for (i = 1; i <= sig->param_count; i++)
1103 mono_mb_emit_ldarg (mb, i);
1104
1105 // push managed return value as byref last argument
1106 if (!MONO_TYPE_IS_VOID (sig->ret) && !preserve_sig)
1107 mono_mb_emit_ldloc_addr (mb, retval);
1108
1109 adjusted_method = cominterop_get_native_wrapper_adjusted (method);
1110 mono_mb_emit_managed_call (mb, adjusted_method, NULL);
1111
1112 if (!preserve_sig) {
1113 if (!ThrowExceptionForHR) {
1114 ERROR_DECL (error);
1115 ThrowExceptionForHR = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "ThrowExceptionForHR", 1, 0, error);
1116 mono_error_assert_ok (error);
1117 }
1118 mono_mb_emit_managed_call (mb, ThrowExceptionForHR, NULL);
1119
1120 // load return value managed is expecting
1121 if (!MONO_TYPE_IS_VOID (sig->ret))
1122 mono_mb_emit_ldloc (mb, retval);
1123 }
1124
1125 mono_mb_emit_byte (mb, CEE_RET);
1126 }
1127
1128
1129 }
1130 /* Does this case ever get hit? */
1131 else {
1132 char *msg = g_strdup ("non imported interfaces on \
1133 imported classes is not yet implemented.");
1134 mono_mb_emit_exception (mb, "NotSupportedException", msg);
1135 }
1136 #endif /* DISABLE_JIT */
1137
1138 csig = mono_metadata_signature_dup_full (m_class_get_image (method->klass), sig);
1139 csig->pinvoke = 0;
1140 res = mono_mb_create_and_cache (cache, method,
1141 mb, csig, csig->param_count + 16);
1142 mono_mb_free (mb);
1143 return res;
1144 }
1145
1146 /**
1147 * mono_cominterop_get_invoke:
1148 * \param method managed method
1149 * \returns the generated method that calls the underlying \c __ComObject
1150 * rather than the proxy object.
1151 */
1152 MonoMethod *
1153 mono_cominterop_get_invoke (MonoMethod *method)
1154 {
1155 MonoMethodSignature *sig;
1156 MonoMethodBuilder *mb;
1157 MonoMethod *res;
1158 int i;
1159 GHashTable* cache;
1160
1161 cache = mono_marshal_get_cache (&mono_method_get_wrapper_cache (method)->cominterop_invoke_cache, mono_aligned_addr_hash, NULL);
1162
1163 g_assert (method);
1164
1165 if ((res = mono_marshal_find_in_cache (cache, method)))
1166 return res;
1167
1168 sig = mono_signature_no_pinvoke (method);
1169
1170 /* we cant remote methods without this pointer */
1171 if (!sig->hasthis)
1172 return method;
1173
1174 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP_INVOKE);
1175
1176 #ifndef DISABLE_JIT
1177 /* get real proxy object, which is a ComInteropProxy in this case*/
1178 mono_mb_add_local (mb, mono_get_object_type ());
1179 mono_mb_emit_ldarg (mb, 0);
1180 mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoTransparentProxy, rp));
1181 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1182
1183 /* load the RCW from the ComInteropProxy*/
1184 mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoComInteropProxy, com_object));
1185 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1186
1187 /* load args and make the call on the RCW */
1188 for (i = 1; i <= sig->param_count; i++)
1189 mono_mb_emit_ldarg (mb, i);
1190
1191 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) || mono_class_is_interface (method->klass)) {
1192 MonoMethod * native_wrapper = mono_cominterop_get_native_wrapper(method);
1193 mono_mb_emit_managed_call (mb, native_wrapper, NULL);
1194 }
1195 else {
1196 if (method->flags & METHOD_ATTRIBUTE_VIRTUAL)
1197 mono_mb_emit_op (mb, CEE_CALLVIRT, method);
1198 else
1199 mono_mb_emit_op (mb, CEE_CALL, method);
1200 }
1201
1202 if (!strcmp(method->name, ".ctor")) {
1203 static MonoMethod *cache_proxy = NULL;
1204
1205 if (!cache_proxy) {
1206 ERROR_DECL (error);
1207 cache_proxy = mono_class_get_method_from_name_checked (mono_class_get_interop_proxy_class (), "CacheProxy", 0, 0, error);
1208 mono_error_assert_ok (error);
1209 }
1210
1211 mono_mb_emit_ldarg (mb, 0);
1212 mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoTransparentProxy, rp));
1213 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1214 mono_mb_emit_managed_call (mb, cache_proxy, NULL);
1215 }
1216
1217 mono_marshal_emit_thread_interrupt_checkpoint (mb);
1218
1219 mono_mb_emit_byte (mb, CEE_RET);
1220 #endif /* DISABLE_JIT */
1221
1222 res = mono_mb_create_and_cache (cache, method, mb, sig, sig->param_count + 16);
1223 mono_mb_free (mb);
1224
1225 return res;
1226 }
1227
1228 /* Maps a managed object to its unmanaged representation
1229 * i.e. it's COM Callable Wrapper (CCW).
1230 * Key: MonoObject*
1231 * Value: MonoCCW*
1232 */
1233 static GHashTable* ccw_hash = NULL;
1234
1235 /* Maps a CCW interface to it's containing CCW.
1236 * Note that a CCW support many interfaces.
1237 * Key: MonoCCW*
1238 * Value: MonoCCWInterface*
1239 */
1240 static GHashTable* ccw_interface_hash = NULL;
1241
1242 /* Maps the IUnknown value of a RCW to
1243 * it's MonoComInteropProxy*.
1244 * Key: void*
1245 * Value: gchandle
1246 */
1247 static GHashTable* rcw_hash = NULL;
1248
1249 int
1250 mono_cominterop_emit_marshal_com_interface (EmitMarshalContext *m, int argnum,
1251 MonoType *t,
1252 MonoMarshalSpec *spec,
1253 int conv_arg, MonoType **conv_arg_type,
1254 MarshalAction action)
1255 {
1256 MonoMethodBuilder *mb = m->mb;
1257 MonoClass *klass = t->data.klass;
1258 static MonoMethod* get_object_for_iunknown = NULL;
1259 static MonoMethod* get_iunknown_for_object_internal = NULL;
1260 static MonoMethod* get_com_interface_for_object_internal = NULL;
1261 static MonoMethod* get_idispatch_for_object_internal = NULL;
1262 static MonoMethod* marshal_release = NULL;
1263 static MonoMethod* AddRef = NULL;
1264 ERROR_DECL (error);
1265 if (!get_object_for_iunknown) {
1266 get_object_for_iunknown = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetObjectForIUnknown", 1, 0, error);
1267 mono_error_assert_ok (error);
1268 }
1269 if (!get_iunknown_for_object_internal) {
1270 get_iunknown_for_object_internal = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetIUnknownForObjectInternal", 1, 0, error);
1271 mono_error_assert_ok (error);
1272 }
1273 if (!get_idispatch_for_object_internal) {
1274 get_idispatch_for_object_internal = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetIDispatchForObjectInternal", 1, 0, error);
1275 mono_error_assert_ok (error);
1276 }
1277 if (!get_com_interface_for_object_internal) {
1278 get_com_interface_for_object_internal = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetComInterfaceForObjectInternal", 2, 0, error);
1279 mono_error_assert_ok (error);
1280 }
1281 if (!marshal_release) {
1282 marshal_release = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "Release", 1, 0, error);
1283 mono_error_assert_ok (error);
1284 }
1285
1286 #ifdef DISABLE_JIT
1287 switch (action) {
1288 case MARSHAL_ACTION_CONV_IN:
1289 *conv_arg_type = mono_get_int_type ();
1290 break;
1291 case MARSHAL_ACTION_MANAGED_CONV_IN:
1292 *conv_arg_type = mono_get_int_type ();
1293 break;
1294 default:
1295 break;
1296 }
1297 #else
1298 switch (action) {
1299 case MARSHAL_ACTION_CONV_IN: {
1300 guint32 pos_null = 0;
1301
1302 MonoType *int_type = mono_get_int_type ();
1303 *conv_arg_type = int_type;
1304 conv_arg = mono_mb_add_local (mb, int_type);
1305
1306 mono_mb_emit_ptr (mb, NULL);
1307 mono_mb_emit_stloc (mb, conv_arg);
1308
1309 /* we dont need any conversions for out parameters */
1310 if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT)
1311 break;
1312
1313 mono_mb_emit_ldarg (mb, argnum);
1314 if (t->byref)
1315 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1316 /* if null just break, conv arg was already inited to 0 */
1317 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1318
1319 mono_mb_emit_ldarg (mb, argnum);
1320 if (t->byref)
1321 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1322
1323 if (klass && klass != mono_defaults.object_class) {
1324 mono_mb_emit_ptr (mb, t);
1325 mono_mb_emit_icall (mb, cominterop_type_from_handle);
1326 mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal, NULL);
1327 }
1328 else if (spec->native == MONO_NATIVE_IUNKNOWN)
1329 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
1330 else if (spec->native == MONO_NATIVE_IDISPATCH)
1331 mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal, NULL);
1332 else if (!klass && spec->native == MONO_NATIVE_INTERFACE)
1333 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
1334 else
1335 g_assert_not_reached ();
1336 mono_mb_emit_stloc (mb, conv_arg);
1337 mono_mb_patch_short_branch (mb, pos_null);
1338 break;
1339 }
1340
1341 case MARSHAL_ACTION_CONV_OUT: {
1342 if (t->byref && (t->attrs & PARAM_ATTRIBUTE_OUT)) {
1343 int ccw_obj;
1344 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
1345 ccw_obj = mono_mb_add_local (mb, mono_get_object_type ());
1346
1347 mono_mb_emit_ldarg (mb, argnum);
1348 mono_mb_emit_byte (mb, CEE_LDNULL);
1349 mono_mb_emit_byte (mb, CEE_STIND_REF);
1350
1351 mono_mb_emit_ldloc (mb, conv_arg);
1352 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1353
1354 mono_mb_emit_ldloc (mb, conv_arg);
1355 mono_mb_emit_icon (mb, TRUE);
1356 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
1357 mono_mb_emit_stloc (mb, ccw_obj);
1358 mono_mb_emit_ldloc (mb, ccw_obj);
1359 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
1360
1361 mono_mb_emit_ldarg (mb, argnum);
1362 mono_mb_emit_ldloc (mb, conv_arg);
1363 mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
1364
1365 if (klass && klass != mono_defaults.object_class)
1366 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1367 mono_mb_emit_byte (mb, CEE_STIND_REF);
1368
1369 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
1370
1371 /* is already managed object */
1372 mono_mb_patch_short_branch (mb, pos_ccw);
1373 mono_mb_emit_ldarg (mb, argnum);
1374 mono_mb_emit_ldloc (mb, ccw_obj);
1375
1376 if (klass && klass != mono_defaults.object_class)
1377 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1378 mono_mb_emit_byte (mb, CEE_STIND_REF);
1379
1380 mono_mb_patch_short_branch (mb, pos_end);
1381
1382 /* need to call Release to follow COM rules of ownership */
1383 mono_mb_emit_ldloc (mb, conv_arg);
1384 mono_mb_emit_managed_call (mb, marshal_release, NULL);
1385 mono_mb_emit_byte (mb, CEE_POP);
1386
1387 /* case if null */
1388 mono_mb_patch_short_branch (mb, pos_null);
1389 }
1390 break;
1391 }
1392 case MARSHAL_ACTION_PUSH:
1393 if (t->byref)
1394 mono_mb_emit_ldloc_addr (mb, conv_arg);
1395 else
1396 mono_mb_emit_ldloc (mb, conv_arg);
1397 break;
1398
1399 case MARSHAL_ACTION_CONV_RESULT: {
1400 int ccw_obj, ret_ptr;
1401 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
1402 ccw_obj = mono_mb_add_local (mb, mono_get_object_type ());
1403 ret_ptr = mono_mb_add_local (mb, mono_get_int_type ());
1404
1405 /* store return value */
1406 mono_mb_emit_stloc (mb, ret_ptr);
1407
1408 mono_mb_emit_ldloc (mb, ret_ptr);
1409 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1410
1411 mono_mb_emit_ldloc (mb, ret_ptr);
1412 mono_mb_emit_icon (mb, TRUE);
1413 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
1414 mono_mb_emit_stloc (mb, ccw_obj);
1415 mono_mb_emit_ldloc (mb, ccw_obj);
1416 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
1417
1418 mono_mb_emit_ldloc (mb, ret_ptr);
1419 mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
1420
1421 if (klass && klass != mono_defaults.object_class)
1422 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1423 mono_mb_emit_stloc (mb, 3);
1424
1425 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
1426
1427 /* is already managed object */
1428 mono_mb_patch_short_branch (mb, pos_ccw);
1429 mono_mb_emit_ldloc (mb, ccw_obj);
1430
1431 if (klass && klass != mono_defaults.object_class)
1432 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1433 mono_mb_emit_stloc (mb, 3);
1434
1435 mono_mb_patch_short_branch (mb, pos_end);
1436
1437 /* need to call Release to follow COM rules of ownership */
1438 mono_mb_emit_ldloc (mb, ret_ptr);
1439 mono_mb_emit_managed_call (mb, marshal_release, NULL);
1440 mono_mb_emit_byte (mb, CEE_POP);
1441
1442 /* case if null */
1443 mono_mb_patch_short_branch (mb, pos_null);
1444 break;
1445 }
1446
1447 case MARSHAL_ACTION_MANAGED_CONV_IN: {
1448 int ccw_obj;
1449 guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
1450 ccw_obj = mono_mb_add_local (mb, mono_get_object_type ());
1451
1452 klass = mono_class_from_mono_type_internal (t);
1453 conv_arg = mono_mb_add_local (mb, m_class_get_byval_arg (klass));
1454 *conv_arg_type = mono_get_int_type ();
1455
1456 mono_mb_emit_byte (mb, CEE_LDNULL);
1457 mono_mb_emit_stloc (mb, conv_arg);
1458 if (t->attrs & PARAM_ATTRIBUTE_OUT)
1459 break;
1460
1461 mono_mb_emit_ldarg (mb, argnum);
1462 if (t->byref)
1463 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1464 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1465
1466 mono_mb_emit_ldarg (mb, argnum);
1467 if (t->byref)
1468 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1469 mono_mb_emit_icon (mb, TRUE);
1470 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
1471 mono_mb_emit_stloc (mb, ccw_obj);
1472 mono_mb_emit_ldloc (mb, ccw_obj);
1473 pos_ccw = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
1474
1475
1476 mono_mb_emit_ldarg (mb, argnum);
1477 if (t->byref)
1478 mono_mb_emit_byte (mb, CEE_LDIND_REF);
1479 mono_mb_emit_managed_call (mb, get_object_for_iunknown, NULL);
1480
1481 if (klass && klass != mono_defaults.object_class)
1482 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1483 mono_mb_emit_stloc (mb, conv_arg);
1484 pos_end = mono_mb_emit_short_branch (mb, CEE_BR_S);
1485
1486 /* is already managed object */
1487 mono_mb_patch_short_branch (mb, pos_ccw);
1488 mono_mb_emit_ldloc (mb, ccw_obj);
1489 if (klass && klass != mono_defaults.object_class)
1490 mono_mb_emit_op (mb, CEE_CASTCLASS, klass);
1491 mono_mb_emit_stloc (mb, conv_arg);
1492
1493 mono_mb_patch_short_branch (mb, pos_end);
1494 /* case if null */
1495 mono_mb_patch_short_branch (mb, pos_null);
1496 break;
1497 }
1498
1499 case MARSHAL_ACTION_MANAGED_CONV_OUT: {
1500 if (t->byref && t->attrs & PARAM_ATTRIBUTE_OUT) {
1501 guint32 pos_null = 0;
1502
1503 if (!AddRef) {
1504 AddRef = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "AddRef", 1, 0, error);
1505 mono_error_assert_ok (error);
1506 }
1507
1508 mono_mb_emit_ldarg (mb, argnum);
1509 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1510 mono_mb_emit_byte (mb, CEE_STIND_I);
1511
1512 mono_mb_emit_ldloc (mb, conv_arg);
1513 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1514
1515 /* to store later */
1516 mono_mb_emit_ldarg (mb, argnum);
1517 mono_mb_emit_ldloc (mb, conv_arg);
1518 if (klass && klass != mono_defaults.object_class) {
1519 mono_mb_emit_ptr (mb, t);
1520 mono_mb_emit_icall (mb, cominterop_type_from_handle);
1521 mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal, NULL);
1522 }
1523 else if (spec->native == MONO_NATIVE_IUNKNOWN)
1524 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
1525 else if (spec->native == MONO_NATIVE_IDISPATCH)
1526 mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal, NULL);
1527 else if (!klass && spec->native == MONO_NATIVE_INTERFACE)
1528 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
1529 else
1530 g_assert_not_reached ();
1531 mono_mb_emit_byte (mb, CEE_STIND_I);
1532
1533 mono_mb_emit_ldarg (mb, argnum);
1534 mono_mb_emit_byte (mb, CEE_LDIND_I);
1535 mono_mb_emit_managed_call (mb, AddRef, NULL);
1536 mono_mb_emit_byte (mb, CEE_POP);
1537
1538 mono_mb_patch_short_branch (mb, pos_null);
1539 }
1540 break;
1541 }
1542
1543 case MARSHAL_ACTION_MANAGED_CONV_RESULT: {
1544 guint32 pos_null = 0;
1545 int ccw_obj;
1546 ccw_obj = mono_mb_add_local (mb, mono_get_object_type ());
1547
1548 if (!AddRef) {
1549 AddRef = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "AddRef", 1, 0, error);
1550 mono_error_assert_ok (error);
1551 }
1552
1553 /* store return value */
1554 mono_mb_emit_stloc (mb, ccw_obj);
1555
1556 mono_mb_emit_ldloc (mb, ccw_obj);
1557
1558 /* if null just break, conv arg was already inited to 0 */
1559 pos_null = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
1560
1561 /* to store later */
1562 mono_mb_emit_ldloc (mb, ccw_obj);
1563 if (klass && klass != mono_defaults.object_class) {
1564 mono_mb_emit_ptr (mb, t);
1565 mono_mb_emit_icall (mb, cominterop_type_from_handle);
1566 mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal, NULL);
1567 }
1568 else if (spec->native == MONO_NATIVE_IUNKNOWN)
1569 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
1570 else if (spec->native == MONO_NATIVE_IDISPATCH)
1571 mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal, NULL);
1572 else if (!klass && spec->native == MONO_NATIVE_INTERFACE)
1573 mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal, NULL);
1574 else
1575 g_assert_not_reached ();
1576 mono_mb_emit_stloc (mb, 3);
1577 mono_mb_emit_ldloc (mb, 3);
1578
1579 mono_mb_emit_managed_call (mb, AddRef, NULL);
1580 mono_mb_emit_byte (mb, CEE_POP);
1581
1582 mono_mb_patch_short_branch (mb, pos_null);
1583 break;
1584 }
1585
1586 default:
1587 g_assert_not_reached ();
1588 }
1589 #endif /* DISABLE_JIT */
1590
1591 return conv_arg;
1592 }
1593
1594 #define MONO_S_OK 0x00000000L
1595 #define MONO_E_NOINTERFACE 0x80004002L
1596 #define MONO_E_NOTIMPL 0x80004001L
1597 #define MONO_E_INVALIDARG 0x80070057L
1598 #define MONO_E_DISP_E_UNKNOWNNAME 0x80020006L
1599 #define MONO_E_DISPID_UNKNOWN (gint32)-1
1600
1601 int
1602 ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (MonoIUnknown *pUnk)
1603 {
1604 return mono_IUnknown_AddRef (pUnk);
1605 }
1606
1607 int
1608 ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (MonoIUnknown *pUnk, gconstpointer riid, gpointer* ppv)
1609 {
1610 return mono_IUnknown_QueryInterface (pUnk, riid, ppv);
1611 }
1612
1613 int
1614 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (MonoIUnknown *pUnk)
1615 {
1616 g_assert (pUnk);
1617 return mono_IUnknown_Release (pUnk);
1618 }
1619
1620 static gboolean
1621 cominterop_can_support_dispatch (MonoClass* klass)
1622 {
1623 if (!mono_class_is_public (klass))
1624 return FALSE;
1625
1626 if (!cominterop_com_visible (klass))
1627 return FALSE;
1628
1629 return TRUE;
1630 }
1631
1632 void*
1633 ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (MonoObjectHandle object, MonoError *error)
1634 {
1635 return mono_cominterop_get_com_interface_internal (TRUE, object, NULL, error);
1636 }
1637
1638 MonoObjectHandle
1639 ves_icall_System_Runtime_InteropServices_Marshal_GetObjectForCCW (void* pUnk, MonoError *error)
1640 {
1641 #ifndef DISABLE_COM
1642 /* see if it is a CCW */
1643 return pUnk ? cominterop_get_ccw_handle ((MonoCCWInterface*)pUnk, TRUE) : NULL_HANDLE;
1644 #else
1645 g_assert_not_reached ();
1646 #endif
1647 }
1648
1649 void*
1650 ves_icall_System_Runtime_InteropServices_Marshal_GetIDispatchForObjectInternal (MonoObjectHandle object, MonoError *error)
1651 {
1652 #ifndef DISABLE_COM
1653 if (MONO_HANDLE_IS_NULL (object))
1654 return NULL;
1655
1656 MonoRealProxyHandle real_proxy;
1657
1658 if (cominterop_object_is_rcw_handle (object, &real_proxy)) {
1659 MonoComInteropProxyHandle com_interop_proxy = MONO_HANDLE_CAST (MonoComInteropProxy, real_proxy);
1660 MonoComObjectHandle com_object = MONO_HANDLE_NEW_GET (MonoComObject, com_interop_proxy, com_object);
1661 return cominterop_get_interface_checked (com_object, mono_class_get_idispatch_class (), error);
1662 }
1663 else if (!cominterop_can_support_dispatch (mono_handle_class (object)) ) {
1664 cominterop_set_hr_error (error, MONO_E_NOINTERFACE);
1665 return NULL;
1666 }
1667 return cominterop_get_ccw_checked (object, mono_class_get_idispatch_class (), error);
1668 #else
1669 g_assert_not_reached ();
1670 #endif
1671 }
1672
1673 void*
1674 ves_icall_System_Runtime_InteropServices_Marshal_GetCCW (MonoObjectHandle object, MonoReflectionTypeHandle ref_type, MonoError *error)
1675 {
1676 #ifndef DISABLE_COM
1677 g_assert (!MONO_HANDLE_IS_NULL (ref_type));
1678 MonoType * const type = MONO_HANDLE_GETVAL (ref_type, type);
1679 g_assert (type);
1680 MonoClass * const klass = mono_type_get_class (type);
1681 g_assert (klass);
1682 if (!mono_class_init_checked (klass, error))
1683 return NULL;
1684 return cominterop_get_ccw_checked (object, klass, error);
1685 #else
1686 g_assert_not_reached ();
1687 #endif
1688 }
1689
1690 MonoBoolean
1691 ves_icall_System_Runtime_InteropServices_Marshal_IsComObject (MonoObjectHandle object, MonoError *error)
1692 {
1693 #ifndef DISABLE_COM
1694 MonoRealProxyHandle real_proxy;
1695 return (MonoBoolean)cominterop_object_is_rcw_handle (object, &real_proxy);
1696 #else
1697 g_assert_not_reached ();
1698 #endif
1699 }
1700
1701 gint32
1702 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseComObjectInternal (MonoObjectHandle object, MonoError *error)
1703 {
1704 #ifndef DISABLE_COM
1705 g_assert (!MONO_HANDLE_IS_NULL (object));
1706
1707 MonoRealProxyHandle real_proxy;
1708 gboolean const is_rcw = cominterop_object_is_rcw_handle (object, &real_proxy);
1709 g_assert (is_rcw);
1710
1711 MonoComInteropProxyHandle proxy = MONO_HANDLE_CAST (MonoComInteropProxy, real_proxy);
1712 g_assert (!MONO_HANDLE_IS_NULL (proxy));
1713
1714 if (MONO_HANDLE_GETVAL (proxy, ref_count) == 0)
1715 return -1;
1716
1717 gint32 ref_count = mono_atomic_dec_i32 (&MONO_HANDLE_GETVAL (proxy, ref_count));
1718 g_assert (ref_count >= 0);
1719
1720 if (ref_count == 0)
1721 mono_System_ComObject_ReleaseInterfaces (MONO_HANDLE_NEW_GET (MonoComObject, proxy, com_object));
1722
1723 return ref_count;
1724 #else
1725 g_assert_not_reached ();
1726 #endif
1727 }
1728
1729 guint32
1730 ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethodHandle m, MonoError *error)
1731 {
1732 #ifndef DISABLE_COM
1733 int const slot = cominterop_get_com_slot_for_method (MONO_HANDLE_GETVAL (m, method), error);
1734 mono_error_assert_ok (error);
1735 return slot;
1736 #else
1737 g_assert_not_reached ();
1738 #endif
1739 }
1740
1741 /* Only used for COM RCWs */
1742 MonoObjectHandle
1743 ves_icall_System_ComObject_CreateRCW (MonoReflectionTypeHandle ref_type, MonoError *error)
1744 {
1745 MonoDomain * const domain = MONO_HANDLE_DOMAIN (ref_type);
1746 MonoType * const type = MONO_HANDLE_GETVAL (ref_type, type);
1747 MonoClass * const klass = mono_class_from_mono_type_internal (type);
1748
1749 /* Call mono_object_new_alloc_by_vtable instead of mono_object_new_by_vtable
1750 * because we want to actually create object. mono_object_new_by_vtable checks
1751 * to see if type is import and creates transparent proxy. This method
1752 * is called by the corresponding real proxy to create the real RCW.
1753 * Constructor does not need to be called. Will be called later.
1754 */
1755 MonoVTable *vtable = mono_class_vtable_checked (domain, klass, error);
1756 return_val_if_nok (error, NULL_HANDLE);
1757 return mono_object_new_alloc_by_vtable (vtable, error);
1758 }
1759
1760 static gboolean
1761 cominterop_rcw_interface_finalizer (gpointer key, gpointer value, gpointer user_data)
1762 {
1763 mono_IUnknown_Release ((MonoIUnknown*)value);
1764 return TRUE;
1765 }
1766
1767 void
1768 mono_System_ComObject_ReleaseInterfaces (MonoComObjectHandle obj)
1769 {
1770 g_assert (!MONO_HANDLE_IS_NULL (obj));
1771 if (!MONO_HANDLE_GETVAL (obj, itf_hash))
1772 return;
1773
1774 mono_cominterop_lock ();
1775 guint32 const gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (rcw_hash, MONO_HANDLE_GETVAL (obj, iunknown)));
1776 if (gchandle) {
1777 mono_gchandle_free_internal (gchandle);
1778 g_hash_table_remove (rcw_hash, MONO_HANDLE_GETVAL (obj, iunknown));
1779 }
1780
1781 g_hash_table_foreach_remove (MONO_HANDLE_GETVAL (obj, itf_hash), cominterop_rcw_interface_finalizer, NULL);
1782 g_hash_table_destroy (MONO_HANDLE_GETVAL (obj, itf_hash));
1783 mono_IUnknown_Release (MONO_HANDLE_GETVAL (obj, iunknown));
1784 MONO_HANDLE_SETVAL (obj, iunknown, MonoIUnknown*, NULL);
1785 MONO_HANDLE_SETVAL (obj, itf_hash, GHashTable*, NULL);
1786 mono_cominterop_unlock ();
1787 }
1788
1789 void
1790 ves_icall_System_ComObject_ReleaseInterfaces (MonoComObjectHandle obj, MonoError *error)
1791 {
1792 mono_System_ComObject_ReleaseInterfaces (obj);
1793 }
1794
1795 static gboolean
1796 cominterop_rcw_finalizer (gpointer key, gpointer value, gpointer user_data)
1797 {
1798 gchandle_t gchandle = 0;
1799
1800 gchandle = GPOINTER_TO_UINT (value);
1801 if (gchandle) {
1802 MonoComInteropProxy* proxy = (MonoComInteropProxy*)mono_gchandle_get_target_internal (gchandle);
1803
1804 if (proxy) {
1805 if (proxy->com_object->itf_hash) {
1806 g_hash_table_foreach_remove (proxy->com_object->itf_hash, cominterop_rcw_interface_finalizer, NULL);
1807 g_hash_table_destroy (proxy->com_object->itf_hash);
1808 }
1809 mono_IUnknown_Release (proxy->com_object->iunknown);
1810 proxy->com_object->iunknown = NULL;
1811 proxy->com_object->itf_hash = NULL;
1812 }
1813
1814 mono_gchandle_free_internal (gchandle);
1815 }
1816
1817 return TRUE;
1818 }
1819
1820 void
1821 mono_cominterop_release_all_rcws (void)
1822 {
1823 #ifndef DISABLE_COM
1824 if (!rcw_hash)
1825 return;
1826
1827 mono_cominterop_lock ();
1828
1829 g_hash_table_foreach_remove (rcw_hash, cominterop_rcw_finalizer, NULL);
1830 g_hash_table_destroy (rcw_hash);
1831 rcw_hash = NULL;
1832
1833 mono_cominterop_unlock ();
1834 #endif
1835 }
1836
1837 gpointer
1838 ves_icall_System_ComObject_GetInterfaceInternal (MonoComObjectHandle obj, MonoReflectionTypeHandle ref_type, MonoBoolean throw_exception, MonoError *error)
1839 {
1840 #ifndef DISABLE_COM
1841 MonoType * const type = MONO_HANDLE_GETVAL (ref_type, type);
1842 MonoClass * const klass = mono_class_from_mono_type_internal (type);
1843 if (!mono_class_init_checked (klass, error))
1844 return NULL;
1845
1846 ERROR_DECL (error_ignored);
1847 gpointer const itf = cominterop_get_interface_checked (obj, klass, throw_exception ? error : error_ignored);
1848 mono_error_cleanup (error_ignored);
1849 return itf;
1850 #else
1851 g_assert_not_reached ();
1852 #endif
1853 }
1854
1855 void
1856 ves_icall_Mono_Interop_ComInteropProxy_AddProxy (gpointer pUnk, MonoComInteropProxyHandle proxy, MonoError *error)
1857 {
1858 #ifndef DISABLE_COM
1859 guint32 const gchandle = mono_gchandle_new_weakref_from_handle (MONO_HANDLE_CAST (MonoObject, proxy));
1860
1861 mono_cominterop_lock ();
1862 if (!rcw_hash)
1863 rcw_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
1864 g_hash_table_insert (rcw_hash, pUnk, GUINT_TO_POINTER (gchandle));
1865 mono_cominterop_unlock ();
1866 #else
1867 g_assert_not_reached ();
1868 #endif
1869 }
1870
1871 MonoComInteropProxyHandle
1872 ves_icall_Mono_Interop_ComInteropProxy_FindProxy (gpointer pUnk, MonoError *error)
1873 {
1874 #ifndef DISABLE_COM
1875 gchandle_t gchandle = 0;
1876
1877 mono_cominterop_lock ();
1878 if (rcw_hash)
1879 gchandle = GPOINTER_TO_UINT (g_hash_table_lookup (rcw_hash, pUnk));
1880 mono_cominterop_unlock ();
1881 if (!gchandle)
1882 return MONO_HANDLE_NEW (MonoComInteropProxy, NULL);
1883
1884 MonoComInteropProxyHandle const proxy = MONO_HANDLE_CAST (MonoComInteropProxy, mono_gchandle_get_target_handle (gchandle));
1885 /* proxy is null means we need to free up old RCW */
1886 if (MONO_HANDLE_IS_NULL (proxy)) {
1887 mono_gchandle_free_internal (gchandle);
1888 g_hash_table_remove (rcw_hash, pUnk);
1889 }
1890 return proxy;
1891 #else
1892 g_assert_not_reached ();
1893 #endif
1894 }
1895
1896 /**
1897 * cominterop_get_ccw_object:
1898 * @ccw_entry: a pointer to the CCWEntry
1899 * @verify: verify ccw_entry is in fact a ccw
1900 *
1901 * Returns: the corresponding object for the CCW
1902 */
1903 static gchandle_t
1904 cominterop_get_ccw_gchandle (MonoCCWInterface* ccw_entry, gboolean verify)
1905 {
1906 /* no CCW's exist yet */
1907 if (!ccw_interface_hash)
1908 return 0;
1909
1910 MonoCCW * const ccw = verify ? (MonoCCW *)g_hash_table_lookup (ccw_interface_hash, ccw_entry) : ccw_entry->ccw;
1911 g_assert (verify || ccw);
1912 return ccw ? ccw->gc_handle : 0;
1913 }
1914
1915 static MonoObjectHandle
1916 cominterop_get_ccw_handle (MonoCCWInterface* ccw_entry, gboolean verify)
1917 {
1918 gchandle_t const gchandle = cominterop_get_ccw_gchandle (ccw_entry, verify);
1919 return gchandle ? mono_gchandle_get_target_handle (gchandle) : NULL_HANDLE;
1920 }
1921
1922 static MonoObject*
1923 cominterop_get_ccw_object (MonoCCWInterface* ccw_entry, gboolean verify)
1924 {
1925 gchandle_t const gchandle = cominterop_get_ccw_gchandle (ccw_entry, verify);
1926 return gchandle ? mono_gchandle_get_target_internal (gchandle) : NULL;
1927 }
1928
1929 static void
1930 cominterop_setup_marshal_context (EmitMarshalContext *m, MonoMethod *method)
1931 {
1932 MonoMethodSignature *sig, *csig;
1933 MonoImage *method_klass_image = m_class_get_image (method->klass);
1934 sig = mono_method_signature_internal (method);
1935 /* we copy the signature, so that we can modify it */
1936 /* FIXME: which to use? */
1937 csig = mono_metadata_signature_dup_full (method_klass_image, sig);
1938 /* csig = mono_metadata_signature_dup (sig); */
1939
1940 /* STDCALL on windows, CDECL everywhere else to work with XPCOM and MainWin COM */
1941 #ifdef HOST_WIN32
1942 csig->call_convention = MONO_CALL_STDCALL;
1943 #else
1944 csig->call_convention = MONO_CALL_C;
1945 #endif
1946 csig->hasthis = 0;
1947 csig->pinvoke = 1;
1948
1949 m->image = method_klass_image;
1950 m->piinfo = NULL;
1951 m->retobj_var = 0;
1952 m->sig = sig;
1953 m->csig = csig;
1954 }
1955
1956 /**
1957 * cominterop_get_ccw_checked:
1958 * @object: a pointer to the object
1959 * @itf: interface type needed
1960 * @error: set on error
1961 *
1962 * Returns: a value indicating if the object is a
1963 * Runtime Callable Wrapper (RCW) for a COM object.
1964 * On failure returns NULL and sets @error.
1965 */
1966 static gpointer
1967 cominterop_get_ccw_checked (MonoObjectHandle object, MonoClass* itf, MonoError *error)
1968 {
1969 int i;
1970 MonoCCW *ccw = NULL;
1971 MonoCCWInterface* ccw_entry = NULL;
1972 gpointer *vtable = NULL;
1973 MonoClass* iface = NULL;
1974 EmitMarshalContext m;
1975 int start_slot = 3;
1976 int method_count = 0;
1977 GList *ccw_list, *ccw_list_item;
1978 MonoCustomAttrInfo *cinfo = NULL;
1979
1980 if (MONO_HANDLE_IS_NULL (object))
1981 return NULL;
1982
1983 MonoClass* klass = mono_handle_class (object);
1984
1985 mono_cominterop_lock ();
1986 if (!ccw_hash)
1987 ccw_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
1988 if (!ccw_interface_hash)
1989 ccw_interface_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
1990
1991 ccw_list = (GList *)g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_handle_hash (object)));
1992 mono_cominterop_unlock ();
1993
1994 ccw_list_item = ccw_list;
1995 while (ccw_list_item) {
1996 MonoCCW* ccw_iter = (MonoCCW *)ccw_list_item->data;
1997 if (mono_gchandle_target_equal (ccw_iter->gc_handle, object)) {
1998 ccw = ccw_iter;
1999 break;
2000 }
2001 ccw_list_item = g_list_next(ccw_list_item);
2002 }
2003
2004 if (!ccw) {
2005 ccw = g_new0 (MonoCCW, 1);
2006 #ifdef HOST_WIN32
2007 ccw->free_marshaler = 0;
2008 #endif
2009 ccw->vtable_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
2010 ccw->ref_count = 0;
2011 /* just alloc a weak handle until we are addref'd*/
2012 ccw->gc_handle = mono_gchandle_new_weakref_from_handle (object);
2013
2014 if (!ccw_list) {
2015 ccw_list = g_list_alloc ();
2016 ccw_list->data = ccw;
2017 }
2018 else
2019 ccw_list = g_list_append (ccw_list, ccw);
2020 mono_cominterop_lock ();
2021 g_hash_table_insert (ccw_hash, GINT_TO_POINTER (mono_handle_hash (object)), ccw_list);
2022 mono_cominterop_unlock ();
2023 /* register for finalization to clean up ccw */
2024 mono_object_register_finalizer_handle (object);
2025 }
2026
2027 cinfo = mono_custom_attrs_from_class_checked (itf, error);
2028 mono_error_assert_ok (error);
2029 if (cinfo) {
2030 static MonoClass* coclass_attribute = NULL;
2031 if (!coclass_attribute)
2032 coclass_attribute = mono_class_load_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "CoClassAttribute");
2033 if (mono_custom_attrs_has_attr (cinfo, coclass_attribute)) {
2034 g_assert(m_class_get_interface_count (itf) && m_class_get_interfaces (itf)[0]);
2035 itf = m_class_get_interfaces (itf)[0];
2036 }
2037 if (!cinfo->cached)
2038 mono_custom_attrs_free (cinfo);
2039 }
2040
2041 iface = itf;
2042 if (iface == mono_class_get_iunknown_class ()) {
2043 start_slot = 3;
2044 }
2045 else if (iface == mono_class_get_idispatch_class ()) {
2046 start_slot = 7;
2047 }
2048 else {
2049 method_count += mono_class_get_method_count (iface);
2050 start_slot = cominterop_get_com_slot_begin (iface);
2051 iface = NULL;
2052 }
2053
2054 ccw_entry = (MonoCCWInterface *)g_hash_table_lookup (ccw->vtable_hash, itf);
2055
2056 if (!ccw_entry) {
2057 int vtable_index = method_count-1+start_slot;
2058 vtable = (void **)mono_image_alloc0 (m_class_get_image (klass), sizeof (gpointer)*(method_count+start_slot));
2059 vtable [0] = (gpointer)cominterop_ccw_queryinterface;
2060 vtable [1] = (gpointer)cominterop_ccw_addref;
2061 vtable [2] = (gpointer)cominterop_ccw_release;
2062 if (start_slot == 7) {
2063 vtable [3] = (gpointer)cominterop_ccw_get_type_info_count;
2064 vtable [4] = (gpointer)cominterop_ccw_get_type_info;
2065 vtable [5] = (gpointer)cominterop_ccw_get_ids_of_names;
2066 vtable [6] = (gpointer)cominterop_ccw_invoke;
2067 }
2068
2069 iface = itf;
2070 for (i = mono_class_get_method_count (iface) - 1; i >= 0; i--) {
2071 int param_index = 0;
2072 MonoMethodBuilder *mb;
2073 MonoMarshalSpec ** mspecs;
2074 MonoMethod *wrapper_method, *adjust_method;
2075 MonoMethod *method = m_class_get_methods (iface) [i];
2076 MonoMethodSignature* sig_adjusted;
2077 MonoMethodSignature* sig = mono_method_signature_internal (method);
2078 gboolean preserve_sig = method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG;
2079
2080 mb = mono_mb_new (iface, method->name, MONO_WRAPPER_NATIVE_TO_MANAGED);
2081 adjust_method = cominterop_get_managed_wrapper_adjusted (method);
2082 sig_adjusted = mono_method_signature_internal (adjust_method);
2083
2084 mspecs = g_new (MonoMarshalSpec*, sig_adjusted->param_count + 1);
2085 mono_method_get_marshal_info (method, mspecs);
2086
2087
2088 /* move managed args up one */
2089 for (param_index = sig->param_count; param_index >= 1; param_index--) {
2090 int mspec_index = param_index+1;
2091 mspecs [mspec_index] = mspecs [param_index];
2092
2093 if (mspecs[mspec_index] == NULL) {
2094 if (sig_adjusted->params[param_index]->type == MONO_TYPE_OBJECT) {
2095 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
2096 mspecs[mspec_index]->native = MONO_NATIVE_STRUCT;
2097 }
2098 else if (sig_adjusted->params[param_index]->type == MONO_TYPE_STRING) {
2099 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
2100 mspecs[mspec_index]->native = MONO_NATIVE_BSTR;
2101 }
2102 else if (sig_adjusted->params[param_index]->type == MONO_TYPE_CLASS) {
2103 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
2104 mspecs[mspec_index]->native = MONO_NATIVE_INTERFACE;
2105 }
2106 else if (sig_adjusted->params[param_index]->type == MONO_TYPE_BOOLEAN) {
2107 mspecs[mspec_index] = g_new0 (MonoMarshalSpec, 1);
2108 mspecs[mspec_index]->native = MONO_NATIVE_VARIANTBOOL;
2109 }
2110 } else {
2111 /* increase SizeParamIndex since we've added a param */
2112 if (sig_adjusted->params[param_index]->type == MONO_TYPE_ARRAY ||
2113 sig_adjusted->params[param_index]->type == MONO_TYPE_SZARRAY)
2114 if (mspecs[mspec_index]->data.array_data.param_num != -1)
2115 mspecs[mspec_index]->data.array_data.param_num++;
2116 }
2117 }
2118
2119 /* first arg is IntPtr for interface */
2120 mspecs [1] = NULL;
2121
2122 /* move return spec to last param */
2123 if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret)) {
2124 if (mspecs [0] == NULL) {
2125 if (sig_adjusted->params[sig_adjusted->param_count-1]->type == MONO_TYPE_OBJECT) {
2126 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
2127 mspecs[0]->native = MONO_NATIVE_STRUCT;
2128 }
2129 else if (sig_adjusted->params[sig_adjusted->param_count-1]->type == MONO_TYPE_STRING) {
2130 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
2131 mspecs[0]->native = MONO_NATIVE_BSTR;
2132 }
2133 else if (sig_adjusted->params[sig_adjusted->param_count-1]->type == MONO_TYPE_CLASS) {
2134 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
2135 mspecs[0]->native = MONO_NATIVE_INTERFACE;
2136 }
2137 else if (sig_adjusted->params[sig_adjusted->param_count-1]->type == MONO_TYPE_BOOLEAN) {
2138 mspecs[0] = g_new0 (MonoMarshalSpec, 1);
2139 mspecs[0]->native = MONO_NATIVE_VARIANTBOOL;
2140 }
2141 }
2142
2143 mspecs [sig_adjusted->param_count] = mspecs [0];
2144 mspecs [0] = NULL;
2145 }
2146
2147 #ifndef DISABLE_JIT
2148 /* skip visiblity since we call internal methods */
2149 mb->skip_visibility = TRUE;
2150 #endif
2151
2152 cominterop_setup_marshal_context (&m, adjust_method);
2153 m.mb = mb;
2154 mono_marshal_emit_managed_wrapper (mb, sig_adjusted, mspecs, &m, adjust_method, 0);
2155 mono_cominterop_lock ();
2156 wrapper_method = mono_mb_create_method (mb, m.csig, m.csig->param_count + 16);
2157 mono_cominterop_unlock ();
2158
2159 vtable [vtable_index--] = mono_compile_method_checked (wrapper_method, error);
2160
2161 // cleanup, then error out if compile_method failed
2162 for (param_index = sig_adjusted->param_count; param_index >= 0; param_index--)
2163 if (mspecs [param_index])
2164 mono_metadata_free_marshal_spec (mspecs [param_index]);
2165 g_free (mspecs);
2166 return_val_if_nok (error, NULL);
2167 }
2168
2169 ccw_entry = g_new0 (MonoCCWInterface, 1);
2170 ccw_entry->ccw = ccw;
2171 ccw_entry->vtable = vtable;
2172 g_hash_table_insert (ccw->vtable_hash, itf, ccw_entry);
2173 g_hash_table_insert (ccw_interface_hash, ccw_entry, ccw);
2174 }
2175
2176 return ccw_entry;
2177 }
2178
2179 /**
2180 * cominterop_get_ccw:
2181 * @object: a pointer to the object
2182 * @itf: interface type needed
2183 *
2184 * Returns: a value indicating if the object is a
2185 * Runtime Callable Wrapper (RCW) for a COM object
2186 */
2187 static gpointer
2188 cominterop_get_ccw (MonoObject* object_raw, MonoClass* itf)
2189 {
2190 HANDLE_FUNCTION_ENTER ();
2191 ERROR_DECL (error);
2192 MONO_HANDLE_DCL (MonoObject, object);
2193 gpointer ccw_entry = cominterop_get_ccw_checked (object, itf, error);
2194 mono_error_set_pending_exception (error);
2195 HANDLE_FUNCTION_RETURN_VAL (ccw_entry);
2196 }
2197
2198 static gboolean
2199 mono_marshal_free_ccw_entry (gpointer key, gpointer value, gpointer user_data)
2200 {
2201 g_hash_table_remove (ccw_interface_hash, value);
2202 g_assert (value);
2203 g_free (value);
2204 return TRUE;
2205 }
2206
2207 /**
2208 * mono_marshal_free_ccw:
2209 * \param object the mono object
2210 * \returns whether the object had a CCW
2211 */
2212 static gboolean
2213 mono_marshal_free_ccw_handle (MonoObjectHandle object)
2214 {
2215 /* no ccw's were created */
2216 if (!ccw_hash || g_hash_table_size (ccw_hash) == 0)
2217 return FALSE;
2218
2219 mono_cominterop_lock ();
2220 GList *ccw_list = (GList *)g_hash_table_lookup (ccw_hash, GINT_TO_POINTER (mono_handle_hash (object)));
2221 mono_cominterop_unlock ();
2222
2223 if (!ccw_list)
2224 return FALSE;
2225
2226 /* need to cache orig list address to remove from hash_table if empty */
2227 GList * const ccw_list_orig = ccw_list;
2228
2229 for (GList* ccw_list_item = ccw_list; ccw_list_item; ) {
2230 MonoCCW* ccw_iter = (MonoCCW *)ccw_list_item->data;
2231 gboolean is_null = FALSE;
2232 gboolean is_equal = FALSE;
2233 mono_gchandle_target_is_null_or_equal (ccw_iter->gc_handle, object, &is_null, &is_equal);
2234
2235 /* Looks like the GC NULLs the weakref handle target before running the
2236 * finalizer. So if we get a NULL target, destroy the CCW as well.
2237 * Unless looking up the object from the CCW shows it not the right object.
2238 */
2239 gboolean destroy_ccw = is_null || is_equal;
2240 if (is_null) {
2241 MonoCCWInterface* ccw_entry = (MonoCCWInterface *)g_hash_table_lookup (ccw_iter->vtable_hash, mono_class_get_iunknown_class ());
2242 gchandle_t gchandle = 0;
2243 if (!(ccw_entry && (gchandle = cominterop_get_ccw_gchandle (ccw_entry, FALSE)) && mono_gchandle_target_equal (gchandle, object)))
2244 destroy_ccw = FALSE;
2245 }
2246 if (destroy_ccw) {
2247 /* remove all interfaces */
2248 g_hash_table_foreach_remove (ccw_iter->vtable_hash, mono_marshal_free_ccw_entry, NULL);
2249 g_hash_table_destroy (ccw_iter->vtable_hash);
2250
2251 /* get next before we delete */
2252 ccw_list_item = g_list_next (ccw_list_item);
2253
2254 /* remove ccw from list */
2255 ccw_list = g_list_remove (ccw_list, ccw_iter);
2256 #ifdef HOST_WIN32
2257 mono_IUnknown_Release (ccw_iter->free_marshaler);
2258 #endif
2259 g_free (ccw_iter);
2260 }
2261 else
2262 ccw_list_item = g_list_next (ccw_list_item);
2263 }
2264
2265 /* if list is empty remove original address from hash */
2266 if (g_list_length (ccw_list) == 0)
2267 g_hash_table_remove (ccw_hash, GINT_TO_POINTER (mono_handle_hash (object)));
2268 else if (ccw_list != ccw_list_orig)
2269 g_hash_table_insert (ccw_hash, GINT_TO_POINTER (mono_handle_hash (object)), ccw_list);
2270
2271 return TRUE;
2272 }
2273
2274 gboolean
2275 mono_marshal_free_ccw (MonoObject* object_raw)
2276 {
2277 /* no ccw's were created */
2278 if (!ccw_hash || g_hash_table_size (ccw_hash) == 0)
2279 return FALSE;
2280
2281 HANDLE_FUNCTION_ENTER ();
2282 MONO_HANDLE_DCL (MonoObject, object);
2283 HANDLE_FUNCTION_RETURN_VAL (mono_marshal_free_ccw_handle (object));
2284 }
2285
2286 /**
2287 * cominterop_get_managed_wrapper_adjusted:
2288 * @method: managed COM Interop method
2289 *
2290 * Returns: the generated method to call with signature matching
2291 * the unmanaged COM Method signature
2292 */
2293 static MonoMethod *
2294 cominterop_get_managed_wrapper_adjusted (MonoMethod *method)
2295 {
2296 static MonoMethod *get_hr_for_exception = NULL;
2297 MonoMethod *res = NULL;
2298 MonoMethodBuilder *mb;
2299 MonoMarshalSpec **mspecs;
2300 MonoMethodSignature *sig, *sig_native;
2301 MonoExceptionClause *main_clause = NULL;
2302 int pos_leave;
2303 int hr = 0;
2304 int i;
2305 gboolean const preserve_sig = (method->iflags & METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG) != 0;
2306
2307 if (!get_hr_for_exception) {
2308 ERROR_DECL (error);
2309 get_hr_for_exception = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetHRForException", -1, 0, error);
2310 mono_error_assert_ok (error);
2311 }
2312
2313 sig = mono_method_signature_internal (method);
2314
2315 /* create unmanaged wrapper */
2316 mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP);
2317
2318 sig_native = cominterop_method_signature (method);
2319
2320 mspecs = g_new0 (MonoMarshalSpec*, sig_native->param_count+1);
2321
2322 mono_method_get_marshal_info (method, mspecs);
2323
2324 /* move managed args up one */
2325 for (i = sig->param_count; i >= 1; i--)
2326 mspecs [i+1] = mspecs [i];
2327
2328 /* first arg is IntPtr for interface */
2329 mspecs [1] = NULL;
2330
2331 /* move return spec to last param */
2332 if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret))
2333 mspecs [sig_native->param_count] = mspecs [0];
2334
2335 mspecs [0] = NULL;
2336
2337 #ifndef DISABLE_JIT
2338 if (!preserve_sig)
2339 hr = mono_mb_add_local (mb, mono_get_int32_type ());
2340 else if (!MONO_TYPE_IS_VOID (sig->ret))
2341 hr = mono_mb_add_local (mb, sig->ret);
2342
2343 /* try */
2344 main_clause = g_new0 (MonoExceptionClause, 1);
2345 main_clause->try_offset = mono_mb_get_label (mb);
2346
2347 /* load last param to store result if not preserve_sig and not void */
2348 if (!preserve_sig && !MONO_TYPE_IS_VOID (sig->ret))
2349 mono_mb_emit_ldarg (mb, sig_native->param_count-1);
2350
2351 /* the CCW -> object conversion */
2352 mono_mb_emit_ldarg (mb, 0);
2353 mono_mb_emit_icon (mb, FALSE);
2354 mono_mb_emit_icall (mb, cominterop_get_ccw_object);
2355
2356 for (i = 0; i < sig->param_count; i++)
2357 mono_mb_emit_ldarg (mb, i+1);
2358
2359 mono_mb_emit_managed_call (mb, method, NULL);
2360
2361 if (!MONO_TYPE_IS_VOID (sig->ret)) {
2362 if (!preserve_sig) {
2363 MonoClass *rclass = mono_class_from_mono_type_internal (sig->ret);
2364 if (m_class_is_valuetype (rclass)) {
2365 mono_mb_emit_op (mb, CEE_STOBJ, rclass);
2366 } else {
2367 mono_mb_emit_byte (mb, mono_type_to_stind (sig->ret));
2368 }
2369 } else
2370 mono_mb_emit_stloc (mb, hr);
2371 }
2372
2373 pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
2374
2375 /* Main exception catch */
2376 main_clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
2377 main_clause->try_len = mono_mb_get_pos (mb) - main_clause->try_offset;
2378 main_clause->data.catch_class = mono_defaults.object_class;
2379
2380 /* handler code */
2381 main_clause->handler_offset = mono_mb_get_label (mb);
2382
2383 if (!preserve_sig || (sig->ret && !sig->ret->byref && (sig->ret->type == MONO_TYPE_U4 || sig->ret->type == MONO_TYPE_I4))) {
2384 mono_mb_emit_managed_call (mb, get_hr_for_exception, NULL);
2385 mono_mb_emit_stloc (mb, hr);
2386 }
2387 else {
2388 mono_mb_emit_byte (mb, CEE_POP);
2389 }
2390
2391 mono_mb_emit_branch (mb, CEE_LEAVE);
2392 main_clause->handler_len = mono_mb_get_pos (mb) - main_clause->handler_offset;
2393 /* end catch */
2394
2395 mono_mb_set_clauses (mb, 1, main_clause);
2396
2397 mono_mb_patch_branch (mb, pos_leave);
2398
2399 if (!preserve_sig || !MONO_TYPE_IS_VOID (sig->ret))
2400 mono_mb_emit_ldloc (mb, hr);
2401
2402 mono_mb_emit_byte (mb, CEE_RET);
2403 #endif /* DISABLE_JIT */
2404
2405 mono_cominterop_lock ();
2406 res = mono_mb_create_method (mb, sig_native, sig_native->param_count + 16);
2407 mono_cominterop_unlock ();
2408
2409 mono_mb_free (mb);
2410
2411 for (i = sig_native->param_count; i >= 0; i--)
2412 mono_metadata_free_marshal_spec (mspecs [i]);
2413 g_free (mspecs);
2414
2415 return res;
2416 }
2417
2418 /**
2419 * cominterop_mono_string_to_guid:
2420 *
2421 * Converts the standard string representation of a GUID
2422 * to a 16 byte Microsoft GUID.
2423 */
2424 static void
2425 cominterop_mono_string_to_guid (MonoString* string, guint8 *guid) {
2426 gunichar2 * chars = mono_string_chars_internal (string);
2427 int i = 0;
2428 static const guint8 indexes[16] = {7, 5, 3, 1, 12, 10, 17, 15, 20, 22, 25, 27, 29, 31, 33, 35};
2429
2430 for (i = 0; i < sizeof(indexes); i++)
2431 guid [i] = g_unichar_xdigit_value (chars [indexes [i]]) + (g_unichar_xdigit_value (chars [indexes [i] - 1]) << 4);
2432 }
2433
2434 static gboolean
2435 cominterop_class_guid_equal (const guint8* guid, MonoClass* klass)
2436 {
2437 guint8 klass_guid [16];
2438 if (cominterop_class_guid (klass, klass_guid))
2439 return !memcmp (guid, klass_guid, sizeof (klass_guid));
2440 return FALSE;
2441 }
2442
2443 static int STDCALL
2444 cominterop_ccw_addref_impl (MonoCCWInterface* ccwe);
2445
2446 static int STDCALL
2447 cominterop_ccw_addref (MonoCCWInterface* ccwe)
2448 {
2449 int result;
2450 MONO_ENTER_GC_UNSAFE;
2451 result = cominterop_ccw_addref_impl (ccwe);
2452 MONO_EXIT_GC_UNSAFE;
2453 return result;
2454 }
2455
2456 static int STDCALL
2457 cominterop_ccw_addref_impl (MonoCCWInterface* ccwe)
2458 {
2459 MONO_REQ_GC_UNSAFE_MODE;
2460 MonoCCW* ccw = ccwe->ccw;
2461 g_assert (ccw);
2462 g_assert (ccw->gc_handle);
2463 gint32 const ref_count = mono_atomic_inc_i32 ((gint32*)&ccw->ref_count);
2464 if (ref_count == 1) {
2465 guint32 oldhandle = ccw->gc_handle;
2466 g_assert (oldhandle);
2467 /* since we now have a ref count, alloc a strong handle*/
2468 ccw->gc_handle = mono_gchandle_from_handle (mono_gchandle_get_target_handle (oldhandle), FALSE);
2469 mono_gchandle_free_internal (oldhandle);
2470 }
2471 return ref_count;
2472 }
2473
2474 static int STDCALL
2475 cominterop_ccw_release_impl (MonoCCWInterface* ccwe);
2476
2477 static int STDCALL
2478 cominterop_ccw_release (MonoCCWInterface* ccwe)
2479 {
2480 int result;
2481 MONO_ENTER_GC_UNSAFE;
2482 result = cominterop_ccw_release_impl (ccwe);
2483 MONO_EXIT_GC_UNSAFE;
2484 return result;
2485 }
2486
2487 static int STDCALL
2488 cominterop_ccw_release_impl (MonoCCWInterface* ccwe)
2489 {
2490 MONO_REQ_GC_UNSAFE_MODE;
2491 MonoCCW* ccw = ccwe->ccw;
2492 g_assert (ccw);
2493 g_assert (ccw->ref_count > 0);
2494 gint32 const ref_count = mono_atomic_dec_i32 ((gint32*)&ccw->ref_count);
2495 if (ref_count == 0) {
2496 /* allow gc of object */
2497 guint32 oldhandle = ccw->gc_handle;
2498 g_assert (oldhandle);
2499 ccw->gc_handle = mono_gchandle_new_weakref_from_handle (mono_gchandle_get_target_handle (oldhandle));
2500 mono_gchandle_free_internal (oldhandle);
2501 }
2502 return ref_count;
2503 }
2504
2505 #ifdef HOST_WIN32
2506 static const IID MONO_IID_IMarshal = {0x3, 0x0, 0x0, {0xC0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x46}};
2507
2508 /* All ccw objects are free threaded */
2509 static int
2510 cominterop_ccw_getfreethreadedmarshaler (MonoCCW* ccw, MonoObjectHandle object, gpointer* ppv, MonoError *error)
2511 {
2512 if (!ccw->free_marshaler) {
2513 gpointer const tunk = cominterop_get_ccw_checked (object, mono_class_get_iunknown_class (), error);
2514 return_val_if_nok (error, MONO_E_NOINTERFACE);
2515 int const ret = CoCreateFreeThreadedMarshaler ((LPUNKNOWN)tunk, (LPUNKNOWN*)&ccw->free_marshaler);
2516 }
2517
2518 return ccw->free_marshaler ? mono_IUnknown_QueryInterface (ccw->free_marshaler, &MONO_IID_IMarshal, ppv)
2519 : MONO_E_NOINTERFACE;
2520 }
2521 #endif
2522
2523 static int STDCALL
2524 cominterop_ccw_queryinterface_impl (MonoCCWInterface* ccwe, const guint8* riid, gpointer* ppv);
2525
2526 static int STDCALL
2527 cominterop_ccw_queryinterface (MonoCCWInterface* ccwe, const guint8* riid, gpointer* ppv)
2528 {
2529 int result;
2530 MONO_ENTER_GC_UNSAFE;
2531 result = cominterop_ccw_queryinterface_impl (ccwe, riid, ppv);
2532 MONO_EXIT_GC_UNSAFE;
2533 return result;
2534 }
2535
2536 static int STDCALL
2537 cominterop_ccw_queryinterface_impl (MonoCCWInterface* ccwe, const guint8* riid, gpointer* ppv)
2538 {
2539 MONO_REQ_GC_UNSAFE_MODE;
2540 ERROR_DECL (error);
2541 GPtrArray *ifaces;
2542 MonoClass *itf = NULL;
2543 int i;
2544 MonoCCW* ccw = ccwe->ccw;
2545 MonoClass* klass_iter = NULL;
2546 MonoObjectHandle object = mono_gchandle_get_target_handle (ccw->gc_handle);
2547
2548 g_assert (!MONO_HANDLE_IS_NULL (object));
2549 MonoClass* const klass = mono_handle_class (object);
2550
2551 if (ppv)
2552 *ppv = NULL;
2553
2554 if (!mono_domain_get ())
2555 mono_thread_attach (mono_get_root_domain ());
2556
2557 /* handle IUnknown special */
2558 if (cominterop_class_guid_equal (riid, mono_class_get_iunknown_class ())) {
2559 *ppv = cominterop_get_ccw_checked (object, mono_class_get_iunknown_class (), error);
2560 mono_error_assert_ok (error);
2561 /* remember to addref on QI */
2562 cominterop_ccw_addref ((MonoCCWInterface *)*ppv);
2563 return MONO_S_OK;
2564 }
2565
2566 /* handle IDispatch special */
2567 if (cominterop_class_guid_equal (riid, mono_class_get_idispatch_class ())) {
2568 if (!cominterop_can_support_dispatch (klass))
2569 return MONO_E_NOINTERFACE;
2570
2571 *ppv = cominterop_get_ccw_checked (object, mono_class_get_idispatch_class (), error);
2572 mono_error_assert_ok (error);
2573 /* remember to addref on QI */
2574 cominterop_ccw_addref ((MonoCCWInterface *)*ppv);
2575 return MONO_S_OK;
2576 }
2577
2578 #ifdef HOST_WIN32
2579 /* handle IMarshal special */
2580 if (0 == memcmp (riid, &MONO_IID_IMarshal, sizeof (IID))) {
2581 int const res = cominterop_ccw_getfreethreadedmarshaler (ccw, object, ppv, error);
2582 mono_error_assert_ok (error);
2583 return res;
2584 }
2585 #endif
2586 klass_iter = klass;
2587 while (klass_iter && klass_iter != mono_defaults.object_class) {
2588 ifaces = mono_class_get_implemented_interfaces (klass_iter, error);
2589 mono_error_assert_ok (error);
2590 if (ifaces) {
2591 for (i = 0; i < ifaces->len; ++i) {
2592 MonoClass *ic = NULL;
2593 ic = (MonoClass *)g_ptr_array_index (ifaces, i);
2594 if (cominterop_class_guid_equal (riid, ic)) {
2595 itf = ic;
2596 break;
2597 }
2598 }
2599 g_ptr_array_free (ifaces, TRUE);
2600 }
2601
2602 if (itf)
2603 break;
2604
2605 klass_iter = m_class_get_parent (klass_iter);
2606 }
2607 if (itf) {
2608 *ppv = cominterop_get_ccw_checked (object, itf, error);
2609 if (!is_ok (error)) {
2610 mono_error_cleanup (error); /* FIXME don't swallow the error */
2611 return MONO_E_NOINTERFACE;
2612 }
2613 /* remember to addref on QI */
2614 cominterop_ccw_addref ((MonoCCWInterface *)*ppv);
2615 return MONO_S_OK;
2616 }
2617
2618 return MONO_E_NOINTERFACE;
2619 }
2620
2621 static int STDCALL
2622 cominterop_ccw_get_type_info_count (MonoCCWInterface* ccwe, guint32 *pctinfo)
2623 {
2624 if(!pctinfo)
2625 return MONO_E_INVALIDARG;
2626
2627 *pctinfo = 1;
2628
2629 return MONO_S_OK;
2630 }
2631
2632 static int STDCALL
2633 cominterop_ccw_get_type_info (MonoCCWInterface* ccwe, guint32 iTInfo, guint32 lcid, gpointer *ppTInfo)
2634 {
2635 return MONO_E_NOTIMPL;
2636 }
2637
2638 static int STDCALL
2639 cominterop_ccw_get_ids_of_names_impl (MonoCCWInterface* ccwe, gpointer riid,
2640 gunichar2** rgszNames, guint32 cNames,
2641 guint32 lcid, gint32 *rgDispId);
2642
2643
2644 static int STDCALL
2645 cominterop_ccw_get_ids_of_names (MonoCCWInterface* ccwe, gpointer riid,
2646 gunichar2** rgszNames, guint32 cNames,
2647 guint32 lcid, gint32 *rgDispId)
2648 {
2649 int result;
2650 MONO_ENTER_GC_UNSAFE;
2651 result = cominterop_ccw_get_ids_of_names_impl (ccwe, riid, rgszNames, cNames, lcid, rgDispId);
2652 MONO_EXIT_GC_UNSAFE;
2653 return result;
2654 }
2655
2656 static int STDCALL
2657 cominterop_ccw_get_ids_of_names_impl (MonoCCWInterface* ccwe, gpointer riid,
2658 gunichar2** rgszNames, guint32 cNames,
2659 guint32 lcid, gint32 *rgDispId)
2660 {
2661 MONO_REQ_GC_UNSAFE_MODE;
2662 static MonoClass *ComDispIdAttribute = NULL;
2663 ERROR_DECL (error);
2664 MonoCustomAttrInfo *cinfo = NULL;
2665 int i,ret = MONO_S_OK;
2666 MonoMethod* method;
2667 gchar* methodname;
2668 MonoClass *klass = NULL;
2669 MonoCCW* ccw = ccwe->ccw;
2670 MonoObject* object = mono_gchandle_get_target_internal (ccw->gc_handle);
2671
2672 /* Handle DispIdAttribute */
2673 if (!ComDispIdAttribute)
2674 ComDispIdAttribute = mono_class_load_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "DispIdAttribute");
2675
2676 g_assert (object);
2677 klass = mono_object_class (object);
2678
2679 if (!mono_domain_get ())
2680 mono_thread_attach (mono_get_root_domain ());
2681
2682 for (i=0; i < cNames; i++) {
2683 methodname = mono_unicode_to_external (rgszNames[i]);
2684
2685 method = mono_class_get_method_from_name_checked(klass, methodname, -1, 0, error);
2686 if (method && is_ok (error)) {
2687 cinfo = mono_custom_attrs_from_method_checked (method, error);
2688 mono_error_assert_ok (error); /* FIXME what's reasonable to do here */
2689 if (cinfo) {
2690 MonoObject *result = mono_custom_attrs_get_attr_checked (cinfo, ComDispIdAttribute, error);
2691 mono_error_assert_ok (error); /*FIXME proper error handling*/;
2692
2693 if (result)
2694 rgDispId[i] = *(gint32*)mono_object_unbox_internal (result);
2695 else
2696 rgDispId[i] = (gint32)method->token;
2697
2698 if (!cinfo->cached)
2699 mono_custom_attrs_free (cinfo);
2700 }
2701 else
2702 rgDispId[i] = (gint32)method->token;
2703 } else {
2704 mono_error_cleanup (error);
2705 error_init (error); /* reuse for next iteration */
2706 rgDispId[i] = MONO_E_DISPID_UNKNOWN;
2707 ret = MONO_E_DISP_E_UNKNOWNNAME;
2708 }
2709 }
2710
2711 return ret;
2712 }
2713
2714 static int STDCALL
2715 cominterop_ccw_invoke (MonoCCWInterface* ccwe, guint32 dispIdMember,
2716 gpointer riid, guint32 lcid,
2717 guint16 wFlags, gpointer pDispParams,
2718 gpointer pVarResult, gpointer pExcepInfo,
2719 guint32 *puArgErr)
2720 {
2721 return MONO_E_NOTIMPL;
2722 }
2723
2724 #ifndef HOST_WIN32
2725
2726 typedef mono_bstr (STDCALL *SysAllocStringLenFunc)(const gunichar* str, guint32 len);
2727 typedef guint32 (STDCALL *SysStringLenFunc)(mono_bstr_const bstr);
2728 typedef void (STDCALL *SysFreeStringFunc)(mono_bstr_const str);
2729
2730 static SysAllocStringLenFunc sys_alloc_string_len_ms = NULL;
2731 static SysStringLenFunc sys_string_len_ms = NULL;
2732 static SysFreeStringFunc sys_free_string_ms = NULL;
2733
2734 typedef struct tagSAFEARRAYBOUND {
2735 ULONG cElements;
2736 LONG lLbound;
2737 }SAFEARRAYBOUND,*LPSAFEARRAYBOUND;
2738 #define VT_VARIANT 12
2739
2740 typedef guint32 (STDCALL *SafeArrayGetDimFunc)(gpointer psa);
2741 typedef int (STDCALL *SafeArrayGetLBoundFunc)(gpointer psa, guint32 nDim, glong* plLbound);
2742 typedef int (STDCALL *SafeArrayGetUBoundFunc)(gpointer psa, guint32 nDim, glong* plUbound);
2743 typedef int (STDCALL *SafeArrayPtrOfIndexFunc)(gpointer psa, glong* rgIndices, gpointer* ppvData);
2744 typedef int (STDCALL *SafeArrayDestroyFunc)(gpointer psa);
2745 typedef int (STDCALL *SafeArrayPutElementFunc)(gpointer psa, glong* rgIndices, gpointer* ppvData);
2746 typedef gpointer (STDCALL *SafeArrayCreateFunc)(int vt, guint32 cDims, SAFEARRAYBOUND* rgsabound);
2747
2748 static SafeArrayGetDimFunc safe_array_get_dim_ms = NULL;
2749 static SafeArrayGetLBoundFunc safe_array_get_lbound_ms = NULL;
2750 static SafeArrayGetUBoundFunc safe_array_get_ubound_ms = NULL;
2751 static SafeArrayPtrOfIndexFunc safe_array_ptr_of_index_ms = NULL;
2752 static SafeArrayDestroyFunc safe_array_destroy_ms = NULL;
2753 static SafeArrayPutElementFunc safe_array_put_element_ms = NULL;
2754 static SafeArrayCreateFunc safe_array_create_ms = NULL;
2755
2756 static gboolean
2757 init_com_provider_ms (void)
2758 {
2759 static gboolean initialized = FALSE;
2760 char *error_msg;
2761 MonoDl *module = NULL;
2762 const char* scope = "liboleaut32.so";
2763
2764 if (initialized) {
2765 // Barrier here prevents reads of sys_alloc_string_len_ms etc.
2766 // from being reordered before initialized.
2767 mono_memory_barrier ();
2768 return TRUE;
2769 }
2770
2771 module = mono_dl_open(scope, MONO_DL_LAZY, &error_msg);
2772 if (error_msg) {
2773 g_warning ("Error loading COM support library '%s': %s", scope, error_msg);
2774 g_assert_not_reached ();
2775 return FALSE;
2776 }
2777 error_msg = mono_dl_symbol (module, "SysAllocStringLen", (gpointer*)&sys_alloc_string_len_ms);
2778 if (error_msg) {
2779 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysAllocStringLen", scope, error_msg);
2780 g_assert_not_reached ();
2781 return FALSE;
2782 }
2783
2784 error_msg = mono_dl_symbol (module, "SysStringLen", (gpointer*)&sys_string_len_ms);
2785 if (error_msg) {
2786 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysStringLen", scope, error_msg);
2787 g_assert_not_reached ();
2788 return FALSE;
2789 }
2790
2791 error_msg = mono_dl_symbol (module, "SysFreeString", (gpointer*)&sys_free_string_ms);
2792 if (error_msg) {
2793 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SysFreeString", scope, error_msg);
2794 g_assert_not_reached ();
2795 return FALSE;
2796 }
2797
2798 error_msg = mono_dl_symbol (module, "SafeArrayGetDim", (gpointer*)&safe_array_get_dim_ms);
2799 if (error_msg) {
2800 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SafeArrayGetDim", scope, error_msg);
2801 g_assert_not_reached ();
2802 return FALSE;
2803 }
2804
2805 error_msg = mono_dl_symbol (module, "SafeArrayGetLBound", (gpointer*)&safe_array_get_lbound_ms);
2806 if (error_msg) {
2807 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SafeArrayGetLBound", scope, error_msg);
2808 g_assert_not_reached ();
2809 return FALSE;
2810 }
2811
2812 error_msg = mono_dl_symbol (module, "SafeArrayGetUBound", (gpointer*)&safe_array_get_ubound_ms);
2813 if (error_msg) {
2814 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SafeArrayGetUBound", scope, error_msg);
2815 g_assert_not_reached ();
2816 return FALSE;
2817 }
2818
2819 error_msg = mono_dl_symbol (module, "SafeArrayPtrOfIndex", (gpointer*)&safe_array_ptr_of_index_ms);
2820 if (error_msg) {
2821 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SafeArrayPtrOfIndex", scope, error_msg);
2822 g_assert_not_reached ();
2823 return FALSE;
2824 }
2825
2826 error_msg = mono_dl_symbol (module, "SafeArrayDestroy", (gpointer*)&safe_array_destroy_ms);
2827 if (error_msg) {
2828 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SafeArrayDestroy", scope, error_msg);
2829 g_assert_not_reached ();
2830 return FALSE;
2831 }
2832
2833 error_msg = mono_dl_symbol (module, "SafeArrayPutElement", (gpointer*)&safe_array_put_element_ms);
2834 if (error_msg) {
2835 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SafeArrayPutElement", scope, error_msg);
2836 g_assert_not_reached ();
2837 return FALSE;
2838 }
2839
2840 error_msg = mono_dl_symbol (module, "SafeArrayCreate", (gpointer*)&safe_array_create_ms);
2841 if (error_msg) {
2842 g_warning ("Error loading entry point '%s' in COM support library '%s': %s", "SafeArrayCreate", scope, error_msg);
2843 g_assert_not_reached ();
2844 return FALSE;
2845 }
2846
2847 mono_memory_barrier ();
2848 initialized = TRUE;
2849 return TRUE;
2850 }
2851
2852 #endif // WIN32
2853 #endif // DISABLE_COM
2854
2855 mono_bstr
2856 mono_ptr_to_bstr (const gunichar2* ptr, int slen)
2857 {
2858 if (!ptr)
2859 return NULL;
2860 #ifdef HOST_WIN32
2861 return SysAllocStringLen (ptr, slen);
2862 #else
2863 #ifndef DISABLE_COM
2864 if (com_provider == MONO_COM_DEFAULT) {
2865 #endif
2866 /* allocate len + 1 utf16 characters plus 4 byte integer for length*/
2867 guint32 * const ret = (guint32 *)g_malloc ((slen + 1) * sizeof (gunichar2) + sizeof (guint32));
2868 if (ret == NULL)
2869 return NULL;
2870 mono_bstr const s = (mono_bstr)(ret + 1);
2871 *ret = slen * sizeof (gunichar2);
2872 memcpy (s, ptr, slen * sizeof (gunichar2));
2873 s [slen] = 0;
2874 return s;
2875 #ifndef DISABLE_COM
2876 }
2877 else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
2878 guint32 const len = slen;
2879 gunichar* const str = g_utf16_to_ucs4 (ptr, len, NULL, NULL, NULL);
2880 mono_bstr const ret = sys_alloc_string_len_ms (str, len);
2881 g_free (str);
2882 return ret;
2883 }
2884 else {
2885 g_assert_not_reached();
2886 }
2887 #endif
2888 #endif
2889 }
2890
2891 static MonoStringHandle
2892 mono_string_from_bstr_checked (mono_bstr_const bstr, MonoError *error)
2893 {
2894 if (!bstr)
2895 return NULL_HANDLE_STRING;
2896 #ifdef HOST_WIN32
2897 return mono_string_new_utf16_handle (mono_domain_get (), bstr, SysStringLen ((BSTR)bstr), error);
2898 #else
2899 #ifndef DISABLE_COM
2900 if (com_provider == MONO_COM_DEFAULT)
2901 #endif
2902 return mono_string_new_utf16_handle (mono_domain_get (), bstr, *((guint32 *)bstr - 1) / sizeof (gunichar2), error);
2903 #ifndef DISABLE_COM
2904 else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
2905 glong written = 0;
2906 // FIXME mono_string_new_utf32_handle to combine g_ucs4_to_utf16 and mono_string_new_utf16_handle.
2907 gunichar2* utf16 = g_ucs4_to_utf16 ((const gunichar *)bstr, sys_string_len_ms (bstr), NULL, &written, NULL);
2908 MonoStringHandle res = mono_string_new_utf16_handle (mono_domain_get (), utf16, written, error);
2909 g_free (utf16);
2910 return res;
2911 } else {
2912 g_assert_not_reached ();
2913 }
2914 #endif // DISABLE_COM
2915 #endif // HOST_WIN32
2916 }
2917
2918 MonoString *
2919 mono_string_from_bstr (/*mono_bstr_const*/gpointer bstr)
2920 {
2921 // FIXME gcmode
2922 HANDLE_FUNCTION_ENTER ();
2923 ERROR_DECL (error);
2924 MonoStringHandle result = mono_string_from_bstr_checked ((mono_bstr_const)bstr, error);
2925 mono_error_cleanup (error);
2926 HANDLE_FUNCTION_RETURN_OBJ (result);
2927 }
2928
2929 MonoStringHandle
2930 mono_string_from_bstr_icall_impl (mono_bstr_const bstr, MonoError *error)
2931 {
2932 return mono_string_from_bstr_checked (bstr, error);
2933 }
2934
2935 MONO_API void
2936 mono_free_bstr (/*mono_bstr_const*/gpointer bstr)
2937 {
2938 if (!bstr)
2939 return;
2940 #ifdef HOST_WIN32
2941 SysFreeString ((BSTR)bstr);
2942 #else
2943 #ifndef DISABLE_COM
2944 if (com_provider == MONO_COM_DEFAULT) {
2945 #endif
2946 g_free (((char *)bstr) - 4);
2947 #ifndef DISABLE_COM
2948 } else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
2949 sys_free_string_ms ((mono_bstr_const)bstr);
2950 } else {
2951 g_assert_not_reached ();
2952 }
2953 #endif // DISABLE_COM
2954 #endif // HOST_WIN32
2955 }
2956
2957 #ifndef DISABLE_COM
2958
2959 /* SAFEARRAY marshalling */
2960 int
2961 mono_cominterop_emit_marshal_safearray (EmitMarshalContext *m, int argnum, MonoType *t,
2962 MonoMarshalSpec *spec,
2963 int conv_arg, MonoType **conv_arg_type,
2964 MarshalAction action)
2965 {
2966 MonoMethodBuilder *mb = m->mb;
2967
2968 #ifndef DISABLE_JIT
2969 switch (action) {
2970 case MARSHAL_ACTION_CONV_IN: {
2971 if (t->attrs & PARAM_ATTRIBUTE_IN) {
2972
2973 /* Generates IL code for the following algorithm:
2974
2975 SafeArray safearray; // safearray_var
2976 IntPtr indices; // indices_var
2977 int empty; // empty_var
2978 if (mono_marshal_safearray_create (array, out safearray, out indices, out empty)) {
2979 if (!empty) {
2980 int index=0; // index_var
2981 do { // label3
2982 variant elem = Marshal.GetNativeVariantForObject (array.GetValueImpl(index));
2983 mono_marshal_safearray_set_value (safearray, indices, elem);
2984 ++index;
2985 }
2986 while (mono_marshal_safearray_next (safearray, indices));
2987 } // label2
2988 mono_marshal_safearray_free_indices (indices);
2989 } // label1
2990 */
2991
2992 int safearray_var, indices_var, empty_var, elem_var, index_var;
2993 guint32 label1 = 0, label2 = 0, label3 = 0;
2994 static MonoMethod *get_native_variant_for_object = NULL;
2995 static MonoMethod *get_value_impl = NULL;
2996 static MonoMethod *variant_clear = NULL;
2997
2998 MonoType *int_type = mono_get_int_type ();
2999 conv_arg = safearray_var = mono_mb_add_local (mb, mono_get_object_type ());
3000 indices_var = mono_mb_add_local (mb, int_type);
3001 empty_var = mono_mb_add_local (mb, int_type);
3002
3003 if (t->byref) {
3004 mono_mb_emit_ldarg (mb, argnum);
3005 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3006 } else
3007 mono_mb_emit_ldarg (mb, argnum);
3008
3009 mono_mb_emit_ldloc_addr (mb, safearray_var);
3010 mono_mb_emit_ldloc_addr (mb, indices_var);
3011 mono_mb_emit_ldloc_addr (mb, empty_var);
3012 mono_mb_emit_icall (mb, mono_marshal_safearray_create);
3013
3014 label1 = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
3015
3016 mono_mb_emit_ldloc (mb, empty_var);
3017
3018 label2 = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
3019
3020 index_var = mono_mb_add_local (mb, mono_get_int32_type ());
3021 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
3022 mono_mb_emit_stloc (mb, index_var);
3023
3024 label3 = mono_mb_get_label (mb);
3025
3026 if (!get_value_impl) {
3027 ERROR_DECL (error);
3028 get_value_impl = mono_class_get_method_from_name_checked (mono_defaults.array_class, "GetValueImpl", 1, 0, error);
3029 mono_error_assert_ok (error);
3030 }
3031 g_assert (get_value_impl);
3032
3033 if (t->byref) {
3034 mono_mb_emit_ldarg (mb, argnum);
3035 mono_mb_emit_byte (mb, CEE_LDIND_REF);
3036 } else
3037 mono_mb_emit_ldarg (mb, argnum);
3038
3039 mono_mb_emit_ldloc (mb, index_var);
3040
3041 mono_mb_emit_managed_call (mb, get_value_impl, NULL);
3042
3043 if (!get_native_variant_for_object) {
3044 ERROR_DECL (error);
3045 get_native_variant_for_object = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetNativeVariantForObject", 2, 0, error);
3046 mono_error_assert_ok (error);
3047 }
3048 g_assert (get_native_variant_for_object);
3049
3050 elem_var = mono_mb_add_local (mb, m_class_get_byval_arg (mono_class_get_variant_class ()));
3051 mono_mb_emit_ldloc_addr (mb, elem_var);
3052
3053 mono_mb_emit_managed_call (mb, get_native_variant_for_object, NULL);
3054
3055 mono_mb_emit_ldloc (mb, safearray_var);
3056 mono_mb_emit_ldloc (mb, indices_var);
3057 mono_mb_emit_ldloc_addr (mb, elem_var);
3058 mono_mb_emit_icall (mb, mono_marshal_safearray_set_value);
3059
3060 if (!variant_clear) {
3061 ERROR_DECL (error);
3062 variant_clear = mono_class_get_method_from_name_checked (mono_class_get_variant_class (), "Clear", 0, 0, error);
3063 mono_error_assert_ok (error);
3064 }
3065
3066 mono_mb_emit_ldloc_addr (mb, elem_var);
3067 mono_mb_emit_managed_call (mb, variant_clear, NULL);
3068
3069 mono_mb_emit_add_to_local (mb, index_var, 1);
3070
3071 mono_mb_emit_ldloc (mb, safearray_var);
3072 mono_mb_emit_ldloc (mb, indices_var);
3073 mono_mb_emit_icall (mb, mono_marshal_safearray_next);
3074 mono_mb_emit_branch_label (mb, CEE_BRTRUE, label3);
3075
3076 mono_mb_patch_short_branch (mb, label2);
3077
3078 mono_mb_emit_ldloc (mb, indices_var);
3079 mono_mb_emit_icall (mb, mono_marshal_safearray_free_indices);
3080
3081 mono_mb_patch_short_branch (mb, label1);
3082 }
3083 break;
3084 }
3085
3086 case MARSHAL_ACTION_PUSH:
3087 if (t->byref)
3088 mono_mb_emit_ldloc_addr (mb, conv_arg);
3089 else
3090 mono_mb_emit_ldloc (mb, conv_arg);
3091 break;
3092
3093 case MARSHAL_ACTION_CONV_OUT: {
3094 if (t->attrs & PARAM_ATTRIBUTE_OUT) {
3095 /* Generates IL code for the following algorithm:
3096
3097 Array result; // result_var
3098 IntPtr indices; // indices_var
3099 int empty; // empty_var
3100 bool byValue = !t->byref && (t->attrs & PARAM_ATTRIBUTE_IN);
3101 if (mono_marshal_safearray_begin(safearray, out result, out indices, out empty, parameter, byValue)) {
3102 if (!empty) {
3103 int index=0; // index_var
3104 do { // label3
3105 if (!byValue || (index < parameter.Length)) {
3106 object elem = Variant.GetObjectForNativeVariant(mono_marshal_safearray_get_value(safearray, indices));
3107 result.SetValueImpl(elem, index);
3108 }
3109 ++index;
3110 }
3111 while (mono_marshal_safearray_next(safearray, indices));
3112 } // label2
3113 mono_marshal_safearray_end(safearray, indices);
3114 } // label1
3115 if (!byValue)
3116 return result;
3117 */
3118
3119 int result_var, indices_var, empty_var, elem_var, index_var;
3120 guint32 label1 = 0, label2 = 0, label3 = 0, label4 = 0;
3121 static MonoMethod *get_object_for_native_variant = NULL;
3122 static MonoMethod *set_value_impl = NULL;
3123 gboolean byValue = !t->byref && (t->attrs & PARAM_ATTRIBUTE_IN);
3124
3125 MonoType *object_type = mono_get_object_type ();
3126 MonoType *int_type = mono_get_int_type ();
3127 result_var = mono_mb_add_local (mb, object_type);
3128 indices_var = mono_mb_add_local (mb, int_type);
3129 empty_var = mono_mb_add_local (mb, int_type);
3130
3131 mono_mb_emit_ldloc (mb, conv_arg);
3132 mono_mb_emit_ldloc_addr (mb, result_var);
3133 mono_mb_emit_ldloc_addr (mb, indices_var);
3134 mono_mb_emit_ldloc_addr (mb, empty_var);
3135 mono_mb_emit_ldarg (mb, argnum);
3136 if (byValue)
3137 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
3138 else
3139 mono_mb_emit_byte (mb, CEE_LDC_I4_1);
3140 mono_mb_emit_icall (mb, mono_marshal_safearray_begin);
3141
3142 label1 = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
3143
3144 mono_mb_emit_ldloc (mb, empty_var);
3145
3146 label2 = mono_mb_emit_short_branch (mb, CEE_BRTRUE_S);
3147
3148 index_var = mono_mb_add_local (mb, int_type);
3149 mono_mb_emit_byte (mb, CEE_LDC_I4_0);
3150 mono_mb_emit_stloc (mb, index_var);
3151
3152 label3 = mono_mb_get_label (mb);
3153
3154 if (byValue) {
3155 mono_mb_emit_ldloc (mb, index_var);
3156 mono_mb_emit_ldarg (mb, argnum);
3157 mono_mb_emit_byte (mb, CEE_LDLEN);
3158 label4 = mono_mb_emit_branch (mb, CEE_BGE);
3159 }
3160
3161 mono_mb_emit_ldloc (mb, conv_arg);
3162 mono_mb_emit_ldloc (mb, indices_var);
3163 mono_mb_emit_icall (mb, mono_marshal_safearray_get_value);
3164
3165 if (!get_object_for_native_variant) {
3166 ERROR_DECL (error);
3167 get_object_for_native_variant = mono_class_get_method_from_name_checked (mono_defaults.marshal_class, "GetObjectForNativeVariant", 1, 0, error);
3168 mono_error_assert_ok (error);
3169 }
3170 g_assert (get_object_for_native_variant);
3171
3172 if (!set_value_impl) {
3173 ERROR_DECL (error);
3174 set_value_impl = mono_class_get_method_from_name_checked (mono_defaults.array_class, "SetValueImpl", 2, 0, error);
3175 mono_error_assert_ok (error);
3176 }
3177 g_assert (set_value_impl);
3178
3179 elem_var = mono_mb_add_local (mb, object_type);
3180
3181 mono_mb_emit_managed_call (mb, get_object_for_native_variant, NULL);
3182 mono_mb_emit_stloc (mb, elem_var);
3183
3184 mono_mb_emit_ldloc (mb, result_var);
3185 mono_mb_emit_ldloc (mb, elem_var);
3186 mono_mb_emit_ldloc (mb, index_var);
3187 mono_mb_emit_managed_call (mb, set_value_impl, NULL);
3188
3189 if (byValue)
3190 mono_mb_patch_short_branch (mb, label4);
3191
3192 mono_mb_emit_add_to_local (mb, index_var, 1);
3193
3194 mono_mb_emit_ldloc (mb, conv_arg);
3195 mono_mb_emit_ldloc (mb, indices_var);
3196 mono_mb_emit_icall (mb, mono_marshal_safearray_next);
3197 mono_mb_emit_branch_label (mb, CEE_BRTRUE, label3);
3198
3199 mono_mb_patch_short_branch (mb, label2);
3200
3201 mono_mb_emit_ldloc (mb, conv_arg);
3202 mono_mb_emit_ldloc (mb, indices_var);
3203 mono_mb_emit_icall (mb, mono_marshal_safearray_end);
3204
3205 mono_mb_patch_short_branch (mb, label1);
3206
3207 if (!byValue) {
3208 mono_mb_emit_ldarg (mb, argnum);
3209 mono_mb_emit_ldloc (mb, result_var);
3210 mono_mb_emit_byte (mb, CEE_STIND_REF);
3211 }
3212 }
3213 break;
3214 }
3215
3216 default:
3217 g_assert_not_reached ();
3218 }
3219 #endif /* DISABLE_JIT */
3220
3221 return conv_arg;
3222 }
3223
3224 #ifdef HOST_WIN32
3225 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
3226 static guint32
3227 mono_marshal_win_safearray_get_dim (gpointer safearray)
3228 {
3229 return SafeArrayGetDim ((SAFEARRAY*)safearray);
3230 }
3231 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
3232
3233 static guint32
3234 mono_marshal_safearray_get_dim (gpointer safearray)
3235 {
3236 return mono_marshal_win_safearray_get_dim (safearray);
3237 }
3238
3239 #else /* HOST_WIN32 */
3240
3241 static guint32
3242 mono_marshal_safearray_get_dim (gpointer safearray)
3243 {
3244 guint32 result=0;
3245 if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
3246 result = safe_array_get_dim_ms (safearray);
3247 } else {
3248 g_assert_not_reached ();
3249 }
3250 return result;
3251 }
3252 #endif /* HOST_WIN32 */
3253
3254 #ifdef HOST_WIN32
3255 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
3256 static int
3257 mono_marshal_win_safe_array_get_lbound (gpointer psa, guint nDim, glong* plLbound)
3258 {
3259 return SafeArrayGetLBound ((SAFEARRAY*)psa, nDim, plLbound);
3260 }
3261 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
3262
3263 static int
3264 mono_marshal_safe_array_get_lbound (gpointer psa, guint nDim, glong* plLbound)
3265 {
3266 return mono_marshal_win_safe_array_get_lbound (psa, nDim, plLbound);
3267 }
3268
3269 #else /* HOST_WIN32 */
3270
3271 static int
3272 mono_marshal_safe_array_get_lbound (gpointer psa, guint nDim, glong* plLbound)
3273 {
3274 int result=MONO_S_OK;
3275 if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
3276 result = safe_array_get_lbound_ms (psa, nDim, plLbound);
3277 } else {
3278 g_assert_not_reached ();
3279 }
3280 return result;
3281 }
3282 #endif /* HOST_WIN32 */
3283
3284 #ifdef HOST_WIN32
3285 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
3286 static int
3287 mono_marshal_win_safe_array_get_ubound (gpointer psa, guint nDim, glong* plUbound)
3288 {
3289 return SafeArrayGetUBound ((SAFEARRAY*)psa, nDim, plUbound);
3290 }
3291 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
3292
3293 static int
3294 mono_marshal_safe_array_get_ubound (gpointer psa, guint nDim, glong* plUbound)
3295 {
3296 return mono_marshal_win_safe_array_get_ubound (psa, nDim, plUbound);
3297 }
3298
3299 #else /* HOST_WIN32 */
3300
3301 static int
3302 mono_marshal_safe_array_get_ubound (gpointer psa, guint nDim, glong* plUbound)
3303 {
3304 int result=MONO_S_OK;
3305 if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
3306 result = safe_array_get_ubound_ms (psa, nDim, plUbound);
3307 } else {
3308 g_assert_not_reached ();
3309 }
3310 return result;
3311 }
3312 #endif /* HOST_WIN32 */
3313
3314 /* This is an icall */
3315 static gboolean
3316 mono_marshal_safearray_begin (gpointer safearray, MonoArray **result, gpointer *indices, gpointer empty, gpointer parameter, gboolean allocateNewArray)
3317 {
3318 ERROR_DECL (error);
3319 int dim;
3320 uintptr_t *sizes;
3321 intptr_t *bounds;
3322 MonoClass *aklass;
3323 int i;
3324 gboolean bounded = FALSE;
3325
3326 #ifndef HOST_WIN32
3327 // If not on windows, check that the MS provider is used as it is
3328 // required for SAFEARRAY support.
3329 // If SAFEARRAYs are not supported, returning FALSE from this
3330 // function will prevent the other mono_marshal_safearray_xxx functions
3331 // from being called.
3332 if ((com_provider != MONO_COM_MS) || !init_com_provider_ms ()) {
3333 return FALSE;
3334 }
3335 #endif
3336
3337 (*(int*)empty) = TRUE;
3338
3339 if (safearray != NULL) {
3340
3341 dim = mono_marshal_safearray_get_dim (safearray);
3342
3343 if (dim > 0) {
3344
3345 *indices = g_malloc (dim * sizeof(int));
3346
3347 sizes = g_newa (uintptr_t, dim);
3348 bounds = g_newa (intptr_t, dim);
3349
3350 for (i=0; i<dim; ++i) {
3351 glong lbound, ubound;
3352 int cursize;
3353 int hr;
3354
3355 hr = mono_marshal_safe_array_get_lbound (safearray, i+1, &lbound);
3356 if (hr < 0) {
3357 cominterop_set_hr_error (error, hr);
3358 if (mono_error_set_pending_exception (error))
3359 return FALSE;
3360 }
3361 if (lbound != 0)
3362 bounded = TRUE;
3363 hr = mono_marshal_safe_array_get_ubound (safearray, i+1, &ubound);
3364 if (hr < 0) {
3365 cominterop_set_hr_error (error, hr);
3366 if (mono_error_set_pending_exception (error))
3367 return FALSE;
3368 }
3369 cursize = ubound-lbound+1;
3370 sizes [i] = cursize;
3371 bounds [i] = lbound;
3372
3373 ((int*)*indices) [i] = lbound;
3374
3375 if (cursize != 0)
3376 (*(int*)empty) = FALSE;
3377 }
3378
3379 if (allocateNewArray) {
3380 aklass = mono_class_create_bounded_array (mono_defaults.object_class, dim, bounded);
3381 *result = mono_array_new_full_checked (mono_domain_get (), aklass, sizes, bounds, error);
3382 if (mono_error_set_pending_exception (error))
3383 return FALSE;
3384 } else {
3385 *result = (MonoArray *)parameter;
3386 }
3387 }
3388 }
3389 return TRUE;
3390 }
3391
3392 /* This is an icall */
3393 #ifdef HOST_WIN32
3394 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
3395 static int
3396 mono_marshal_win_safearray_get_value (gpointer safearray, gpointer indices, gpointer *result)
3397 {
3398 return SafeArrayPtrOfIndex ((SAFEARRAY*)safearray, (LONG*)indices, result);
3399 }
3400 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
3401
3402 static gpointer
3403 mono_marshal_safearray_get_value (gpointer safearray, gpointer indices)
3404 {
3405 ERROR_DECL (error);
3406 gpointer result;
3407
3408 int hr = mono_marshal_win_safearray_get_value (safearray, indices, &result);
3409 if (hr < 0) {
3410 cominterop_set_hr_error (error, hr);
3411 mono_error_set_pending_exception (error);
3412 result = NULL;
3413 }
3414
3415 return result;
3416 }
3417
3418 #else /* HOST_WIN32 */
3419
3420 static gpointer
3421 mono_marshal_safearray_get_value (gpointer safearray, gpointer indices)
3422 {
3423 ERROR_DECL (error);
3424 gpointer result;
3425
3426 if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
3427 int hr = safe_array_ptr_of_index_ms (safearray, (glong *)indices, &result);
3428 if (hr < 0) {
3429 cominterop_set_hr_error (error, hr);
3430 mono_error_set_pending_exception (error);
3431 return NULL;
3432 }
3433 } else {
3434 g_assert_not_reached ();
3435 }
3436 return result;
3437 }
3438 #endif /* HOST_WIN32 */
3439
3440 /* This is an icall */
3441 static
3442 gboolean mono_marshal_safearray_next (gpointer safearray, gpointer indices)
3443 {
3444 ERROR_DECL (error);
3445 int i;
3446 int dim = mono_marshal_safearray_get_dim (safearray);
3447 gboolean ret= TRUE;
3448 int *pIndices = (int*) indices;
3449 int hr;
3450
3451 for (i=dim-1; i>=0; --i)
3452 {
3453 glong lbound, ubound;
3454
3455 hr = mono_marshal_safe_array_get_ubound (safearray, i+1, &ubound);
3456 if (hr < 0) {
3457 cominterop_set_hr_error (error, hr);
3458 mono_error_set_pending_exception (error);
3459 return FALSE;
3460 }
3461
3462 if (++pIndices[i] <= ubound) {
3463 break;
3464 }
3465
3466 hr = mono_marshal_safe_array_get_lbound (safearray, i+1, &lbound);
3467 if (hr < 0) {
3468 cominterop_set_hr_error (error, hr);
3469 mono_error_set_pending_exception (error);
3470 return FALSE;
3471 }
3472
3473 pIndices[i] = lbound;
3474
3475 if (i == 0)
3476 ret = FALSE;
3477 }
3478 return ret;
3479 }
3480
3481 #ifdef HOST_WIN32
3482 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
3483 static void
3484 mono_marshal_win_safearray_end (gpointer safearray, gpointer indices)
3485 {
3486 g_free(indices);
3487 SafeArrayDestroy ((SAFEARRAY*)safearray);
3488 }
3489 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
3490
3491 static void
3492 mono_marshal_safearray_end (gpointer safearray, gpointer indices)
3493 {
3494 mono_marshal_win_safearray_end (safearray, indices);
3495 }
3496
3497 #else /* HOST_WIN32 */
3498
3499 static void
3500 mono_marshal_safearray_end (gpointer safearray, gpointer indices)
3501 {
3502 g_free(indices);
3503 if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
3504 safe_array_destroy_ms (safearray);
3505 } else {
3506 g_assert_not_reached ();
3507 }
3508 }
3509 #endif /* HOST_WIN32 */
3510
3511 #ifdef HOST_WIN32
3512 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
3513 static gboolean
3514 mono_marshal_win_safearray_create_internal (UINT cDims, SAFEARRAYBOUND *rgsabound, gpointer *newsafearray)
3515 {
3516 *newsafearray = SafeArrayCreate (VT_VARIANT, cDims, rgsabound);
3517 return TRUE;
3518 }
3519 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
3520
3521 static gboolean
3522 mono_marshal_safearray_create_internal (UINT cDims, SAFEARRAYBOUND *rgsabound, gpointer *newsafearray)
3523 {
3524 return mono_marshal_win_safearray_create_internal (cDims, rgsabound, newsafearray);
3525 }
3526
3527 #else /* HOST_WIN32 */
3528
3529 static gboolean
3530 mono_marshal_safearray_create_internal (UINT cDims, SAFEARRAYBOUND *rgsabound, gpointer *newsafearray)
3531 {
3532 *newsafearray = safe_array_create_ms (VT_VARIANT, cDims, rgsabound);
3533 return TRUE;
3534 }
3535
3536 #endif /* HOST_WIN32 */
3537
3538 static gboolean
3539 mono_marshal_safearray_create (MonoArray *input, gpointer *newsafearray, gpointer *indices, gpointer empty)
3540 {
3541 #ifndef HOST_WIN32
3542 // If not on windows, check that the MS provider is used as it is
3543 // required for SAFEARRAY support.
3544 // If SAFEARRAYs are not supported, returning FALSE from this
3545 // function will prevent the other mono_marshal_safearray_xxx functions
3546 // from being called.
3547 if (com_provider != MONO_COM_MS || !init_com_provider_ms ()) {
3548 return FALSE;
3549 }
3550 #endif
3551
3552 int const max_array_length = mono_array_length_internal (input);
3553 int const dim = m_class_get_rank (mono_object_class (input));
3554
3555 *indices = g_malloc (dim * sizeof (int));
3556 SAFEARRAYBOUND * const bounds = g_newa (SAFEARRAYBOUND, dim);
3557 (*(int*)empty) = (max_array_length == 0);
3558
3559 if (dim > 1) {
3560 for (int i = 0; i < dim; ++i) {
3561 ((int*)*indices) [i] = bounds [i].lLbound = input->bounds [i].lower_bound;
3562 bounds [i].cElements = input->bounds [i].length;
3563 }
3564 } else {
3565 ((int*)*indices) [0] = 0;
3566 bounds [0].cElements = max_array_length;
3567 bounds [0].lLbound = 0;
3568 }
3569
3570 return mono_marshal_safearray_create_internal (dim, bounds, newsafearray);
3571 }
3572
3573 /* This is an icall */
3574 #ifdef HOST_WIN32
3575 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT)
3576 static int
3577 mono_marshal_win_safearray_set_value (gpointer safearray, gpointer indices, gpointer value)
3578 {
3579 return SafeArrayPutElement ((SAFEARRAY*)safearray, (LONG*)indices, value);
3580 }
3581 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT | HAVE_UWP_WINAPI_SUPPORT) */
3582
3583 #endif /* HOST_WIN32 */
3584
3585 static void
3586 mono_marshal_safearray_set_value (gpointer safearray, gpointer indices, gpointer value)
3587 {
3588 ERROR_DECL (error);
3589 #ifdef HOST_WIN32
3590 int const hr = mono_marshal_win_safearray_set_value (safearray, indices, value);
3591 #else
3592 int hr = 0;
3593 if (com_provider == MONO_COM_MS && init_com_provider_ms ())
3594 hr = safe_array_put_element_ms (safearray, (glong *)indices, (void **)value);
3595 else
3596 g_assert_not_reached ();
3597 #endif
3598 if (hr < 0) {
3599 cominterop_set_hr_error (error, hr);
3600 mono_error_set_pending_exception (error);
3601 }
3602 }
3603
3604 static
3605 void mono_marshal_safearray_free_indices (gpointer indices)
3606 {
3607 g_free (indices);
3608 }
3609
3610 #else /* DISABLE_COM */
3611
3612 void
3613 mono_cominterop_cleanup (void)
3614 {
3615 }
3616
3617 void
3618 mono_cominterop_release_all_rcws (void)
3619 {
3620 }
3621
3622 gboolean
3623 mono_marshal_free_ccw (MonoObject* object)
3624 {
3625 return FALSE;
3626 }
3627
3628 int
3629 ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (MonoIUnknown *pUnk)
3630 {
3631 g_assert_not_reached ();
3632 return 0;
3633 }
3634
3635 int
3636 ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (MonoIUnknown *pUnk)
3637 {
3638 g_assert_not_reached ();
3639 return 0;
3640 }
3641
3642 int
3643 ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (MonoIUnknown *pUnk, gconstpointer riid, gpointer* ppv)
3644 {
3645 g_assert_not_reached ();
3646 return 0;
3647 }
3648
3649 #endif /* DISABLE_COM */
3650
3651 MonoStringHandle
3652 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (mono_bstr_const ptr, MonoError *error)
3653 {
3654 return mono_string_from_bstr_checked (ptr, error);
3655 }
3656
3657 mono_bstr
3658 ves_icall_System_Runtime_InteropServices_Marshal_BufferToBSTR (const gunichar2* ptr, int len)
3659 {
3660 return mono_ptr_to_bstr (ptr, len);
3661 }
3662
3663 void
3664 ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (mono_bstr_const ptr)
3665 {
3666 mono_free_bstr ((gpointer)ptr);
3667 }
3668
3669 void*
3670 mono_cominterop_get_com_interface (MonoObject *object_raw, MonoClass *ic, MonoError *error)
3671 {
3672 HANDLE_FUNCTION_ENTER ();
3673 MONO_HANDLE_DCL (MonoObject, object);
3674 HANDLE_FUNCTION_RETURN_VAL (mono_cominterop_get_com_interface_internal (FALSE, object, ic, error));
3675 }
3676
3677 static void*
3678 mono_cominterop_get_com_interface_internal (gboolean icall, MonoObjectHandle object, MonoClass *ic, MonoError *error)
3679 {
3680 // Common code for mono_cominterop_get_com_interface and
3681 // ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal,
3682 // which are almost identical.
3683 #ifndef DISABLE_COM
3684 if (MONO_HANDLE_IS_NULL (object))
3685 return NULL;
3686
3687 MonoRealProxyHandle real_proxy;
3688
3689 if (cominterop_object_is_rcw_handle (object, &real_proxy)) {
3690 MonoClass *klass = NULL;
3691 klass = mono_handle_class (object);
3692 if (!mono_class_is_transparent_proxy (klass)) {
3693 g_assertf (!icall, "Class is not transparent");
3694 mono_error_set_invalid_operation (error, "Class is not transparent");
3695 return NULL;
3696 }
3697
3698 if (MONO_HANDLE_IS_NULL (real_proxy)) {
3699 g_assertf (!icall, "RealProxy is null");
3700 mono_error_set_invalid_operation (error, "RealProxy is null");
3701 return NULL;
3702 }
3703
3704 klass = mono_handle_class (real_proxy);
3705 if (klass != mono_class_get_interop_proxy_class ()) {
3706 g_assertf (!icall, "Object is not a proxy");
3707 mono_error_set_invalid_operation (error, "Object is not a proxy");
3708 return NULL;
3709 }
3710
3711 MonoComInteropProxyHandle com_interop_proxy = MONO_HANDLE_CAST (MonoComInteropProxy, real_proxy);
3712 MonoComObjectHandle com_object = MONO_HANDLE_NEW_GET (MonoComObject, com_interop_proxy, com_object);
3713
3714 if (MONO_HANDLE_IS_NULL (com_object)) {
3715 g_assertf (!icall, "Proxy points to null COM object");
3716 mono_error_set_invalid_operation (error, "Proxy points to null COM object");
3717 return NULL;
3718 }
3719
3720 if (icall)
3721 return MONO_HANDLE_GETVAL (com_object, iunknown);
3722 return cominterop_get_interface_checked (com_object, ic, error);
3723 }
3724 else {
3725 if (icall)
3726 ic = mono_class_get_iunknown_class ();
3727 return cominterop_get_ccw_checked (object, ic, error);
3728 }
3729 #else
3730 g_assert_not_reached ();
3731 #endif
3732 }
Mirror of the official Mono project git repository