MonoExceptionHandle mono_get_exception_runtime_wrapped_handle (MonoObjectHandle wrapped_exception, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; MonoMethod *method; klass = mono_class_load_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", "RuntimeWrappedException"); MonoObjectHandle o = mono_object_new_handle (mono_domain_get (), klass, error); mono_error_assert_ok (error); g_assert (!MONO_HANDLE_IS_NULL (o)); method = mono_class_get_method_from_name_checked (klass, ".ctor", 1, 0, error); mono_error_assert_ok (error); g_assert (method); gpointer args [ ] = { MONO_HANDLE_RAW (wrapped_exception) }; mono_runtime_invoke_handle (method, o, args, error); goto_if_nok (error, return_null); goto exit; return_null: o = mono_new_null (); exit: HANDLE_FUNCTION_RETURN_REF (MonoException, MONO_HANDLE_CAST (MonoException, o)); }
gpointer ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned, MonoStringHandle name, MonoBoolean *created, MonoError *error) { gpointer mutex; *created = TRUE; /* Need to blow away any old errors here, because code tests * for ERROR_ALREADY_EXISTS on success (!) to see if a mutex * was freshly created */ mono_w32error_set_last (ERROR_SUCCESS); if (MONO_HANDLE_IS_NULL (name)) { mutex = mutex_create (owned); } else { gchar *utf8_name = mono_string_handle_to_utf8 (name, error); return_val_if_nok (error, NULL); mutex = namedmutex_create (owned, utf8_name); if (mono_w32error_get_last () == ERROR_ALREADY_EXISTS) *created = FALSE; g_free (utf8_name); } return mutex; }
/* * mono_dynamic_image_register_token: * * Register the TOKEN->OBJ mapping in the mapping table in ASSEMBLY. This is required for * the Module.ResolveXXXToken () methods to work. */ void mono_dynamic_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObjectHandle obj, int how_collide) { MONO_REQ_GC_UNSAFE_MODE; g_assert (!MONO_HANDLE_IS_NULL (obj)); g_assert (strcmp (m_class_get_name (mono_handle_class (obj)), "EnumBuilder")); dynamic_image_lock (assembly); MonoObject *prev = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token)); if (prev) { switch (how_collide) { case MONO_DYN_IMAGE_TOK_NEW: g_warning ("%s: Unexpected previous object when called with MONO_DYN_IMAGE_TOK_NEW", __func__); break; case MONO_DYN_IMAGE_TOK_SAME_OK: if (prev != MONO_HANDLE_RAW (obj)) { g_warning ("%s: condition `prev == MONO_HANDLE_RAW (obj)' not met", __func__); } break; case MONO_DYN_IMAGE_TOK_REPLACE: break; default: g_assert_not_reached (); } } mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), MONO_HANDLE_RAW (obj)); dynamic_image_unlock (assembly); }
gpointer mono_object_handle_pin_unbox (MonoObjectHandle obj, uint32_t *gchandle) { g_assert (!MONO_HANDLE_IS_NULL (obj)); MonoClass *klass = mono_handle_class (obj); g_assert (m_class_is_valuetype (klass)); *gchandle = mono_gchandle_from_handle (obj, TRUE); return mono_object_unbox_internal (MONO_HANDLE_RAW (obj)); }
/* * Returns TRUE if there is "something" where the Authenticode signature is * normally located. Returns FALSE is data directory is empty. * * Note: Neither the structure nor the signature is verified by this function. */ MonoBoolean ves_icall_System_Security_Policy_Evidence_IsAuthenticodePresent (MonoReflectionAssemblyHandle refass, MonoError *error) { error_init (error); if (MONO_HANDLE_IS_NULL (refass)) return FALSE; MonoAssembly *assembly = MONO_HANDLE_GETVAL (refass, assembly); if (assembly && assembly->image) { return (MonoBoolean)mono_image_has_authenticode_entry (assembly->image); } return FALSE; }
static MonoExceptionHandle mono_exception_new_argument_internal (const char *type, const char *arg, const char *msg, MonoError *error) { MonoExceptionHandle ex = mono_exception_new_by_name_msg (mono_get_corlib (), "System", type, msg, error); if (arg && !MONO_HANDLE_IS_NULL (ex)) { MonoArgumentExceptionHandle argex = MONO_HANDLE_CAST (MonoArgumentException, ex); MonoStringHandle arg_str = mono_string_new_handle (MONO_HANDLE_DOMAIN (ex), arg, error); MONO_HANDLE_SET (argex, param_name, arg_str); } return ex; }
// For efficiency, call mono_error_set_pending_exception instead of mono_error_set_pending_exception_slow. gboolean mono_error_set_pending_exception_slow (MonoError *error) { if (is_ok (error)) return FALSE; HANDLE_FUNCTION_ENTER (); MonoExceptionHandle ex = mono_error_convert_to_exception_handle (error); gboolean const result = !MONO_HANDLE_IS_NULL (ex); if (result) mono_set_pending_exception_handle (ex); HANDLE_FUNCTION_RETURN_VAL (result); }
MonoStringHandle ves_icall_Mono_Runtime_GetNativeStackTrace (MonoExceptionHandle exc, MonoError *error) { char *trace; MonoStringHandle res; error_init (error); if (MONO_HANDLE_IS_NULL (exc)) { mono_error_set_argument_null (error, "exception", ""); return NULL_HANDLE_STRING; } trace = mono_exception_handle_get_native_backtrace (exc); res = mono_string_new_handle (mono_domain_get (), trace, error); g_free (trace); return res; }
char * mono_exception_handle_get_native_backtrace (MonoExceptionHandle exc) { #ifdef HAVE_BACKTRACE_SYMBOLS MonoDomain *domain; MonoArrayHandle arr = MONO_HANDLE_NEW(MonoArray, NULL); int i, len; GString *text; char **messages; MONO_HANDLE_GET (arr, exc, native_trace_ips); if (MONO_HANDLE_IS_NULL(arr)) return g_strdup (""); domain = mono_domain_get (); len = mono_array_handle_length (arr); text = g_string_new_len (NULL, len * 20); uint32_t gchandle; gpointer *addr = MONO_ARRAY_HANDLE_PIN (arr, gpointer, 0, &gchandle); MONO_ENTER_GC_SAFE; messages = backtrace_symbols (addr, len); MONO_EXIT_GC_SAFE; mono_gchandle_free_internal (gchandle); for (i = 0; i < len; ++i) { gpointer ip; MONO_HANDLE_ARRAY_GETVAL (ip, arr, gpointer, i); MonoJitInfo *ji = mono_jit_info_table_find (domain, ip); if (ji) { char *msg = mono_debug_print_stack_frame (mono_jit_info_get_method (ji), (char*)ip - (char*)ji->code_start, domain); g_string_append_printf (text, "%s\n", msg); g_free (msg); } else { g_string_append_printf (text, "%s\n", messages [i]); } } g_free (messages); return g_string_free (text, FALSE); #else return g_strdup (""); #endif }
static MonoExceptionHandle create_exception_two_strings (MonoClass *klass, MonoStringHandle a1, MonoStringHandle a2, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoMethod *method = NULL; int const count = 1 + !MONO_HANDLE_IS_NULL (a2); gpointer iter; MonoMethod *m; MonoObjectHandle o = mono_object_new_handle (mono_domain_get (), klass, error); mono_error_assert_ok (error); iter = NULL; while ((m = mono_class_get_methods (klass, &iter))) { MonoMethodSignature *sig; if (strcmp (".ctor", mono_method_get_name (m))) continue; sig = mono_method_signature_internal (m); if (sig->param_count != count) continue; if (sig->params [0]->type != MONO_TYPE_STRING) continue; if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING) continue; method = m; break; } gpointer args [ ] = { MONO_HANDLE_RAW (a1), MONO_HANDLE_RAW (a2) }; mono_runtime_invoke_handle (method, o, args, error); if (!is_ok (error)) o = mono_new_null (); HANDLE_FUNCTION_RETURN_REF (MonoException, MONO_HANDLE_CAST (MonoException, o)); }
static MonoExceptionHandle mono_exception_new_argument_internal (const char *type, const char *arg, const char *msg, MonoError *error) { #ifdef ENABLE_NETCORE MonoStringHandle arg_str = arg ? mono_string_new_handle (mono_domain_get (), arg, error) : NULL_HANDLE_STRING; MonoStringHandle msg_str = msg ? mono_string_new_handle (mono_domain_get (), msg, error) : NULL_HANDLE_STRING; if (!strcmp (type, "ArgumentException")) return mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", type, msg_str, arg_str, error); else return mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", type, arg_str, msg_str, error); #else MonoExceptionHandle ex = mono_exception_new_by_name_msg (mono_get_corlib (), "System", type, msg, error); if (arg && !MONO_HANDLE_IS_NULL (ex)) { MonoArgumentExceptionHandle argex = MONO_HANDLE_CAST (MonoArgumentException, ex); MonoStringHandle arg_str = mono_string_new_handle (MONO_HANDLE_DOMAIN (ex), arg, error); MONO_HANDLE_SET (argex, param_name, arg_str); } return ex; #endif }
static MonoStringHandle get_type_name_as_mono_string (MonoErrorInternal *error, MonoDomain *domain, MonoError *error_out) { HANDLE_FUNCTION_ENTER (); MonoStringHandle res = NULL_HANDLE_STRING; if (error->type_name) { res = string_new_cleanup (domain, error->type_name); } else { MonoClass *klass = get_class (error); if (klass) { char *name = mono_type_full_name (m_class_get_byval_arg (klass)); if (name) { res = string_new_cleanup (domain, name); g_free (name); } } } if (MONO_HANDLE_IS_NULL (res)) mono_error_set_out_of_memory (error_out, "Could not allocate type name"); HANDLE_FUNCTION_RETURN_REF (MonoString, res); }
/*Can fail with out-of-memory*/ MonoException* mono_error_prepare_exception (MonoError *oerror, MonoError *error_out) { HANDLE_FUNCTION_ENTER (); MonoErrorInternal *error = (MonoErrorInternal*)oerror; MonoExceptionHandle exception = MONO_HANDLE_CAST (MonoException, mono_new_null ()); MonoDomain *domain = mono_domain_get (); char *type_name = NULL; char *message = NULL; error_init (error_out); const guint16 error_code = error->error_code; g_assert (error_code != MONO_ERROR_CLEANUP_CALLED_SENTINEL); switch (error_code) { case MONO_ERROR_NONE: goto exit; case MONO_ERROR_MISSING_METHOD: exception = mono_corlib_exception_new_with_args ("System", "MissingMethodException", error->full_message, error->first_argument, error_out); break; case MONO_ERROR_BAD_IMAGE: exception = mono_corlib_exception_new_with_args ("System", "BadImageFormatException", error->full_message, error->first_argument, error_out); break; case MONO_ERROR_FILE_NOT_FOUND: exception = mono_corlib_exception_new_with_args ("System.IO", "FileNotFoundException", error->full_message, error->first_argument, error_out); break; case MONO_ERROR_MISSING_FIELD: exception = mono_corlib_exception_new_with_args ("System", "MissingFieldException", error->full_message, error->first_argument, error_out); break; case MONO_ERROR_MEMBER_ACCESS: exception = mono_exception_new_by_name_msg (mono_defaults.corlib, "System", "MemberAccessException", error->full_message, error_out); break; case MONO_ERROR_TYPE_LOAD: { MonoStringHandle assembly_name; MonoStringHandle type_name; if ((error->type_name && error->assembly_name) || error->exn.klass) { type_name = get_type_name_as_mono_string (error, domain, error_out); if (!mono_error_ok (error_out)) break; if (error->assembly_name) { assembly_name = string_new_cleanup (domain, error->assembly_name); if (MONO_HANDLE_IS_NULL (assembly_name)) { mono_error_set_out_of_memory (error_out, "Could not allocate assembly name"); break; } } else { assembly_name = mono_string_empty_handle (domain); } exception = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System", "TypeLoadException", type_name, assembly_name, error_out); if (!MONO_HANDLE_IS_NULL (exception)) { const char *full_message = error->full_message; if (full_message && full_message [0]) { MonoStringHandle msg = string_new_cleanup (mono_domain_get (), full_message); if (!MONO_HANDLE_IS_NULL (msg)) MONO_HANDLE_SET (exception, message, msg); else mono_error_set_out_of_memory (error_out, "Could not allocate exception object"); } } } else { exception = mono_exception_new_by_name_msg (mono_defaults.corlib, "System", "TypeLoadException", error->full_message, error_out); } } break; case MONO_ERROR_OUT_OF_MEMORY: if (domain) exception = MONO_HANDLE_NEW (MonoException, domain->out_of_memory_ex); if (MONO_HANDLE_IS_NULL (exception)) exception = mono_get_exception_out_of_memory_handle (); break; case MONO_ERROR_ARGUMENT: exception = mono_exception_new_argument (error->first_argument, error->full_message, error_out); break; case MONO_ERROR_ARGUMENT_NULL: exception = mono_exception_new_argument_null (error->first_argument, error_out); break; case MONO_ERROR_ARGUMENT_OUT_OF_RANGE: exception = mono_exception_new_argument_out_of_range(error->first_argument, error->full_message, error_out); break; case MONO_ERROR_NOT_VERIFIABLE: if (error->exn.klass) { type_name = mono_type_get_full_name (error->exn.klass); if (!type_name) goto out_of_memory; } message = g_strdup_printf ("Error in %s:%s %s", type_name, error->member_name, error->full_message); if (!message) goto out_of_memory; exception = mono_exception_new_by_name_msg (mono_defaults.corlib, "System.Security", "VerificationException", message, error_out); break; case MONO_ERROR_GENERIC: if (!error->exception_name_space || !error->exception_name) mono_error_set_execution_engine (error_out, "MonoError with generic error but no exception name was supplied"); else exception = mono_exception_new_by_name_msg (mono_defaults.corlib, error->exception_name_space, error->exception_name, error->full_message, error_out); break; case MONO_ERROR_EXCEPTION_INSTANCE: exception = MONO_HANDLE_CAST (MonoException, mono_gchandle_get_target_handle (error->exn.instance_handle)); break; case MONO_ERROR_CLEANUP_CALLED_SENTINEL: mono_error_set_execution_engine (error_out, "MonoError reused after mono_error_cleanup"); break; case MONO_ERROR_INVALID_PROGRAM: exception = mono_exception_new_by_name_msg (mono_defaults.corlib, "System", "InvalidProgramException", (error->flags & MONO_ERROR_INCOMPLETE) ? "" : error->full_message, error_out); break; default: mono_error_set_execution_engine (error_out, "Invalid error-code %d", error->error_code); } if (!mono_error_ok (error_out)) goto return_null; if (MONO_HANDLE_IS_NULL (exception)) mono_error_set_out_of_memory (error_out, "Could not allocate exception object"); goto exit; out_of_memory: mono_error_set_out_of_memory (error_out, "Could not allocate message"); goto exit; return_null: exception = MONO_HANDLE_CAST (MonoException, mono_new_null ()); exit: g_free (message); g_free (type_name); HANDLE_FUNCTION_RETURN_OBJ (exception); }