mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-15 17:10:51 -10:00
[runtime] Mark mono_string_to_utf8 external only.
Runtime should use mono_string_to_utf8_checked.
This commit is contained in:
1 parent
5cb30c7c72
commit
b884d173c7
24 files changed
+413
-168
No files matched your search
@@ -706,6 +706,7 @@ mono_domain_set (MonoDomain *domain, gboolean force)
|
||||
MonoObject *
|
||||
ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
|
||||
{
|
||||
MonoError error;
|
||||
MonoDomain *add;
|
||||
MonoObject *o;
|
||||
char *str;
|
||||
@@ -716,7 +717,9 @@ ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
|
||||
add = ad->data;
|
||||
g_assert (add);
|
||||
|
||||
str = mono_string_to_utf8 (name);
|
||||
str = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
|
||||
mono_domain_lock (add);
|
||||
|
||||
@@ -959,7 +962,9 @@ ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomai
|
||||
#else
|
||||
char *fname;
|
||||
|
||||
fname = mono_string_to_utf8 (friendly_name);
|
||||
fname = mono_string_to_utf8_checked (friendly_name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
ad = mono_domain_create_appdomain_internal (fname, setup, &error);
|
||||
|
||||
g_free (fname);
|
||||
@@ -2029,7 +2034,9 @@ ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname, MonoBoolean re
|
||||
return NULL;
|
||||
}
|
||||
|
||||
name = filename = mono_string_to_utf8 (fname);
|
||||
name = filename = mono_string_to_utf8_checked (fname, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
|
||||
ass = mono_assembly_open_full (filename, &status, refOnly);
|
||||
|
||||
@@ -2106,7 +2113,9 @@ ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoString *assRef,
|
||||
|
||||
g_assert (assRef);
|
||||
|
||||
name = mono_string_to_utf8 (assRef);
|
||||
name = mono_string_to_utf8_checked (assRef, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
parsed = mono_assembly_name_parse (name, &aname);
|
||||
g_free (name);
|
||||
|
||||
|
||||
@@ -2888,6 +2888,7 @@ get_per_domain_assembly_binding_info (MonoDomain *domain, MonoAssemblyName *anam
|
||||
static MonoAssemblyName*
|
||||
mono_assembly_apply_binding (MonoAssemblyName *aname, MonoAssemblyName *dest_name)
|
||||
{
|
||||
MonoError error;
|
||||
MonoAssemblyBindingInfo *info, *info2;
|
||||
MonoImage *ppimage;
|
||||
MonoDomain *domain;
|
||||
@@ -2918,7 +2919,9 @@ mono_assembly_apply_binding (MonoAssemblyName *aname, MonoAssemblyName *dest_nam
|
||||
if (domain && domain->setup && domain->setup->configuration_file) {
|
||||
mono_domain_lock (domain);
|
||||
if (!domain->assembly_bindings_parsed) {
|
||||
gchar *domain_config_file_name = mono_string_to_utf8 (domain->setup->configuration_file);
|
||||
gchar *domain_config_file_name = mono_string_to_utf8_checked (domain->setup->configuration_file, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
|
||||
gchar *domain_config_file_path = mono_portability_find_file (domain_config_file_name, TRUE);
|
||||
|
||||
if (!domain_config_file_path)
|
||||
|
||||
@@ -498,13 +498,21 @@ ves_icall_System_ConsoleDriver_TtySetup (MonoString *keypad, MonoString *teardow
|
||||
if (setup_finished)
|
||||
return TRUE;
|
||||
|
||||
keypad_xmit_str = keypad != NULL ? mono_string_to_utf8 (keypad) : NULL;
|
||||
keypad_xmit_str = NULL;
|
||||
if (keypad != NULL) {
|
||||
keypad_xmit_str = mono_string_to_utf8_checked (keypad, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
console_set_signal_handlers ();
|
||||
setup_finished = TRUE;
|
||||
if (!atexit_called) {
|
||||
if (teardown != NULL)
|
||||
teardown_str = mono_string_to_utf8 (teardown);
|
||||
if (teardown != NULL) {
|
||||
teardown_str = mono_string_to_utf8_checked (teardown, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
mono_atexit (tty_teardown);
|
||||
}
|
||||
|
||||
@@ -918,6 +918,7 @@ print_name_space (MonoClass *klass)
|
||||
void
|
||||
mono_object_describe (MonoObject *obj)
|
||||
{
|
||||
MonoError error;
|
||||
MonoClass* klass;
|
||||
const char* sep;
|
||||
if (!obj) {
|
||||
@@ -926,7 +927,8 @@ mono_object_describe (MonoObject *obj)
|
||||
}
|
||||
klass = mono_object_class (obj);
|
||||
if (klass == mono_defaults.string_class) {
|
||||
char *utf8 = mono_string_to_utf8 ((MonoString*)obj);
|
||||
char *utf8 = mono_string_to_utf8_checked ((MonoString*)obj, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
if (strlen (utf8) > 60) {
|
||||
utf8 [57] = '.';
|
||||
utf8 [58] = '.';
|
||||
|
||||
+11
-6
@@ -461,15 +461,16 @@ incremental_find_check_match (IncrementalFind *handle, WIN32_FIND_DATA *data, Mo
|
||||
MonoString *
|
||||
ves_icall_System_IO_MonoIO_FindFirst (MonoString *path,
|
||||
MonoString *path_with_pattern,
|
||||
gint32 *result_attr, gint32 *error,
|
||||
gint32 *result_attr, gint32 *ioerror,
|
||||
gpointer *handle)
|
||||
{
|
||||
MonoError error;
|
||||
WIN32_FIND_DATA data;
|
||||
HANDLE find_handle;
|
||||
IncrementalFind *ifh;
|
||||
MonoString *result;
|
||||
|
||||
*error = ERROR_SUCCESS;
|
||||
*ioerror = ERROR_SUCCESS;
|
||||
|
||||
find_handle = FindFirstFile (mono_string_chars (path_with_pattern), &data);
|
||||
|
||||
@@ -480,13 +481,15 @@ ves_icall_System_IO_MonoIO_FindFirst (MonoString *path,
|
||||
if (find_error == ERROR_FILE_NOT_FOUND)
|
||||
return NULL;
|
||||
|
||||
*error = find_error;
|
||||
*ioerror = find_error;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ifh = g_new (IncrementalFind, 1);
|
||||
ifh->find_handle = find_handle;
|
||||
ifh->utf8_path = mono_string_to_utf8 (path);
|
||||
ifh->utf8_path = mono_string_to_utf8_checked (path, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
ifh->domain = mono_domain_get ();
|
||||
*handle = ifh;
|
||||
|
||||
@@ -494,7 +497,7 @@ ves_icall_System_IO_MonoIO_FindFirst (MonoString *path,
|
||||
if (FindNextFile (find_handle, &data) == FALSE){
|
||||
int e = GetLastError ();
|
||||
if (e != ERROR_NO_MORE_FILES)
|
||||
*error = e;
|
||||
*ioerror = e;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
@@ -1233,9 +1236,11 @@ void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
|
||||
gint64
|
||||
mono_filesize_from_path (MonoString *string)
|
||||
{
|
||||
MonoError error;
|
||||
struct stat buf;
|
||||
gint64 res;
|
||||
char *path = mono_string_to_utf8 (string);
|
||||
char *path = mono_string_to_utf8_checked (string, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
|
||||
MONO_ENTER_GC_SAFE;
|
||||
if (stat (path, &buf) == -1)
|
||||
|
||||
@@ -227,13 +227,19 @@ is_special_zero_size_file (struct stat *buf)
|
||||
XXX implement options
|
||||
*/
|
||||
static void*
|
||||
open_file_map (MonoString *path, int input_fd, int mode, gint64 *capacity, int access, int options, int *error)
|
||||
open_file_map (MonoString *path, int input_fd, int mode, gint64 *capacity, int access, int options, int *ioerror)
|
||||
{
|
||||
MonoError error;
|
||||
struct stat buf;
|
||||
char *c_path = path ? mono_string_to_utf8 (path) : NULL;
|
||||
char *c_path = NULL;
|
||||
MmapHandle *handle = NULL;
|
||||
int result, fd;
|
||||
|
||||
if (path) {
|
||||
c_path = mono_string_to_utf8_checked (path, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
}
|
||||
|
||||
if (path)
|
||||
result = stat (c_path, &buf);
|
||||
else
|
||||
@@ -241,13 +247,13 @@ open_file_map (MonoString *path, int input_fd, int mode, gint64 *capacity, int a
|
||||
|
||||
if (mode == FILE_MODE_TRUNCATE || mode == FILE_MODE_APPEND || mode == FILE_MODE_OPEN) {
|
||||
if (result == -1) { //XXX translate errno?
|
||||
*error = FILE_NOT_FOUND;
|
||||
*ioerror = FILE_NOT_FOUND;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
if (mode == FILE_MODE_CREATE_NEW && result == 0) {
|
||||
*error = FILE_ALREADY_EXISTS;
|
||||
*ioerror = FILE_ALREADY_EXISTS;
|
||||
goto done;
|
||||
}
|
||||
|
||||
@@ -258,17 +264,17 @@ open_file_map (MonoString *path, int input_fd, int mode, gint64 *capacity, int a
|
||||
* also makes little sense, so don't do the check if th file is one of these.
|
||||
*/
|
||||
if (buf.st_size == 0 && !is_special_zero_size_file (&buf)) {
|
||||
*error = CAPACITY_SMALLER_THAN_FILE_SIZE;
|
||||
*ioerror = CAPACITY_SMALLER_THAN_FILE_SIZE;
|
||||
goto done;
|
||||
}
|
||||
*capacity = buf.st_size;
|
||||
} else if (*capacity < buf.st_size) {
|
||||
*error = CAPACITY_SMALLER_THAN_FILE_SIZE;
|
||||
*ioerror = CAPACITY_SMALLER_THAN_FILE_SIZE;
|
||||
goto done;
|
||||
}
|
||||
} else {
|
||||
if (mode == FILE_MODE_CREATE_NEW && *capacity == 0) {
|
||||
*error = CAPACITY_SMALLER_THAN_FILE_SIZE;
|
||||
*ioerror = CAPACITY_SMALLER_THAN_FILE_SIZE;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
@@ -279,7 +285,7 @@ open_file_map (MonoString *path, int input_fd, int mode, gint64 *capacity, int a
|
||||
fd = dup (input_fd);
|
||||
|
||||
if (fd == -1) { //XXX translate errno?
|
||||
*error = COULD_NOT_OPEN;
|
||||
*ioerror = COULD_NOT_OPEN;
|
||||
goto done;
|
||||
}
|
||||
|
||||
@@ -299,27 +305,29 @@ done:
|
||||
|
||||
#define MONO_ANON_FILE_TEMPLATE "/mono.anonmap.XXXXXXXXX"
|
||||
static void*
|
||||
open_memory_map (MonoString *mapName, int mode, gint64 *capacity, int access, int options, int *error)
|
||||
open_memory_map (MonoString *mapName, int mode, gint64 *capacity, int access, int options, int *ioerror)
|
||||
{
|
||||
MonoError error;
|
||||
char *c_mapName;
|
||||
MmapHandle *handle;
|
||||
if (*capacity <= 1) {
|
||||
*error = CAPACITY_MUST_BE_POSITIVE;
|
||||
*ioerror = CAPACITY_MUST_BE_POSITIVE;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!(mode == FILE_MODE_CREATE_NEW || mode == FILE_MODE_OPEN_OR_CREATE || mode == FILE_MODE_OPEN)) {
|
||||
*error = INVALID_FILE_MODE;
|
||||
*ioerror = INVALID_FILE_MODE;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
c_mapName = mono_string_to_utf8 (mapName);
|
||||
c_mapName = mono_string_to_utf8_checked (mapName, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
|
||||
named_regions_lock ();
|
||||
handle = (MmapHandle*)g_hash_table_lookup (named_regions, c_mapName);
|
||||
if (handle) {
|
||||
if (mode == FILE_MODE_CREATE_NEW) {
|
||||
*error = FILE_ALREADY_EXISTS;
|
||||
*ioerror = FILE_ALREADY_EXISTS;
|
||||
goto done;
|
||||
}
|
||||
|
||||
@@ -332,7 +340,7 @@ open_memory_map (MonoString *mapName, int mode, gint64 *capacity, int access, in
|
||||
int unused G_GNUC_UNUSED, alloc_size;
|
||||
|
||||
if (mode == FILE_MODE_OPEN) {
|
||||
*error = FILE_NOT_FOUND;
|
||||
*ioerror = FILE_NOT_FOUND;
|
||||
goto done;
|
||||
}
|
||||
*capacity = align_up_to_page_size (*capacity);
|
||||
@@ -340,7 +348,7 @@ open_memory_map (MonoString *mapName, int mode, gint64 *capacity, int access, in
|
||||
tmp_dir = g_get_tmp_dir ();
|
||||
alloc_size = strlen (tmp_dir) + strlen (MONO_ANON_FILE_TEMPLATE) + 1;
|
||||
if (alloc_size > 1024) {//rather fail that stack overflow
|
||||
*error = COULD_NOT_MAP_MEMORY;
|
||||
*ioerror = COULD_NOT_MAP_MEMORY;
|
||||
goto done;
|
||||
}
|
||||
file_name = (char *)alloca (alloc_size);
|
||||
@@ -349,7 +357,7 @@ open_memory_map (MonoString *mapName, int mode, gint64 *capacity, int access, in
|
||||
|
||||
fd = mkstemp (file_name);
|
||||
if (fd == -1) {
|
||||
*error = COULD_NOT_MAP_MEMORY;
|
||||
*ioerror = COULD_NOT_MAP_MEMORY;
|
||||
goto done;
|
||||
}
|
||||
|
||||
@@ -375,24 +383,26 @@ done:
|
||||
|
||||
|
||||
void *
|
||||
mono_mmap_open_file (MonoString *path, int mode, MonoString *mapName, gint64 *capacity, int access, int options, int *error)
|
||||
mono_mmap_open_file (MonoString *path, int mode, MonoString *mapName, gint64 *capacity, int access, int options, int *ioerror)
|
||||
{
|
||||
MonoError error;
|
||||
g_assert (path || mapName);
|
||||
|
||||
if (!mapName)
|
||||
return open_file_map (path, -1, mode, capacity, access, options, error);
|
||||
return open_file_map (path, -1, mode, capacity, access, options, ioerror);
|
||||
|
||||
if (path) {
|
||||
MmapHandle *handle;
|
||||
char *c_mapName = mono_string_to_utf8 (mapName);
|
||||
char *c_mapName = mono_string_to_utf8_checked (mapName, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
|
||||
named_regions_lock ();
|
||||
handle = (MmapHandle*)g_hash_table_lookup (named_regions, c_mapName);
|
||||
if (handle) {
|
||||
*error = FILE_ALREADY_EXISTS;
|
||||
*ioerror = FILE_ALREADY_EXISTS;
|
||||
handle = NULL;
|
||||
} else {
|
||||
handle = (MmapHandle *)open_file_map (path, -1, mode, capacity, access, options, error);
|
||||
handle = (MmapHandle *)open_file_map (path, -1, mode, capacity, access, options, ioerror);
|
||||
if (handle) {
|
||||
handle->name = g_strdup (c_mapName);
|
||||
g_hash_table_insert (named_regions, handle->name, handle);
|
||||
@@ -404,26 +414,28 @@ mono_mmap_open_file (MonoString *path, int mode, MonoString *mapName, gint64 *ca
|
||||
return handle;
|
||||
}
|
||||
|
||||
return open_memory_map (mapName, mode, capacity, access, options, error);
|
||||
return open_memory_map (mapName, mode, capacity, access, options, ioerror);
|
||||
}
|
||||
|
||||
void *
|
||||
mono_mmap_open_handle (void *input_fd, MonoString *mapName, gint64 *capacity, int access, int options, int *error)
|
||||
mono_mmap_open_handle (void *input_fd, MonoString *mapName, gint64 *capacity, int access, int options, int *ioerror)
|
||||
{
|
||||
MonoError error;
|
||||
MmapHandle *handle;
|
||||
if (!mapName) {
|
||||
handle = (MmapHandle *)open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, error);
|
||||
handle = (MmapHandle *)open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, ioerror);
|
||||
} else {
|
||||
char *c_mapName = mono_string_to_utf8 (mapName);
|
||||
char *c_mapName = mono_string_to_utf8_checked (mapName, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
|
||||
named_regions_lock ();
|
||||
handle = (MmapHandle*)g_hash_table_lookup (named_regions, c_mapName);
|
||||
if (handle) {
|
||||
*error = FILE_ALREADY_EXISTS;
|
||||
*ioerror = FILE_ALREADY_EXISTS;
|
||||
handle = NULL;
|
||||
} else {
|
||||
//XXX we're exploiting wapi HANDLE == FD equivalence. THIS IS FRAGILE, create a _wapi_handle_to_fd call
|
||||
handle = (MmapHandle *)open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, error);
|
||||
handle = (MmapHandle *)open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, ioerror);
|
||||
handle->name = g_strdup (c_mapName);
|
||||
g_hash_table_insert (named_regions, handle->name, handle);
|
||||
}
|
||||
|
||||
@@ -149,13 +149,16 @@ ves_icall_System_IO_InotifyWatcher_GetInotifyInstance ()
|
||||
int
|
||||
ves_icall_System_IO_InotifyWatcher_AddWatch (int fd, MonoString *name, gint32 mask)
|
||||
{
|
||||
MonoError error;
|
||||
char *str, *path;
|
||||
int retval;
|
||||
|
||||
if (name == NULL)
|
||||
return -1;
|
||||
|
||||
str = mono_string_to_utf8 (name);
|
||||
str = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return -1;
|
||||
path = mono_portability_find_file (str, TRUE);
|
||||
if (!path)
|
||||
path = str;
|
||||
|
||||
+80
-41
@@ -1477,31 +1477,41 @@ ves_icall_System_Type_internal_from_name (MonoString *name,
|
||||
MonoBoolean ignoreCase)
|
||||
{
|
||||
MonoError error;
|
||||
char *str = mono_string_to_utf8 (name);
|
||||
MonoTypeNameParse info;
|
||||
MonoReflectionType *type;
|
||||
MonoReflectionType *type = NULL;
|
||||
gboolean parsedOk;
|
||||
|
||||
char *str = mono_string_to_utf8_checked (name, &error);
|
||||
if (!is_ok (&error))
|
||||
goto leave;
|
||||
|
||||
parsedOk = mono_reflection_parse_type (str, &info);
|
||||
|
||||
/* mono_reflection_parse_type() mangles the string */
|
||||
if (!parsedOk) {
|
||||
mono_reflection_free_type_info (&info);
|
||||
if (throwOnError) {
|
||||
mono_error_init (&error);
|
||||
if (throwOnError)
|
||||
mono_error_set_argument (&error, "typeName", "failed parse: %s", str);
|
||||
mono_error_set_pending_exception (&error);
|
||||
}
|
||||
g_free (str);
|
||||
return NULL;
|
||||
goto leave;
|
||||
}
|
||||
|
||||
type = type_from_parsed_name (&info, ignoreCase, &error);
|
||||
|
||||
mono_reflection_free_type_info (&info);
|
||||
g_free (str);
|
||||
|
||||
if (!mono_error_ok (&error)) {
|
||||
if (!is_ok (&error))
|
||||
goto leave;
|
||||
|
||||
if (type == NULL){
|
||||
if (throwOnError) {
|
||||
mono_error_set_type_load_name (&error, g_strdup (str), NULL, "");
|
||||
goto leave;
|
||||
}
|
||||
}
|
||||
|
||||
leave:
|
||||
g_free (str);
|
||||
if (!is_ok (&error)) {
|
||||
if (throwOnError)
|
||||
mono_error_set_pending_exception (&error);
|
||||
else
|
||||
@@ -1509,18 +1519,6 @@ ves_icall_System_Type_internal_from_name (MonoString *name,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (type == NULL){
|
||||
MonoException *e = NULL;
|
||||
|
||||
if (throwOnError)
|
||||
e = mono_get_exception_type_load (name, NULL);
|
||||
|
||||
if (e) {
|
||||
mono_set_pending_exception (e);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
@@ -3345,7 +3343,9 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, M
|
||||
}
|
||||
|
||||
name = mono_array_get (params, MonoString *, 1);
|
||||
str = mono_string_to_utf8 (name);
|
||||
str = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
|
||||
do {
|
||||
MonoClassField* field = mono_class_get_field_from_name (k, str);
|
||||
@@ -3388,7 +3388,9 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, M
|
||||
}
|
||||
|
||||
name = mono_array_get (params, MonoString *, 1);
|
||||
str = mono_string_to_utf8 (name);
|
||||
str = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
|
||||
do {
|
||||
MonoClassField* field = mono_class_get_field_from_name (k, str);
|
||||
@@ -3840,7 +3842,9 @@ handle_parent:
|
||||
|
||||
if (name != NULL) {
|
||||
if (utf8_name == NULL) {
|
||||
utf8_name = mono_string_to_utf8 (name);
|
||||
utf8_name = mono_string_to_utf8_checked (name, &error);
|
||||
if (!is_ok (&error))
|
||||
goto fail;
|
||||
compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp;
|
||||
}
|
||||
|
||||
@@ -4039,8 +4043,11 @@ ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, gui
|
||||
return res;
|
||||
}
|
||||
|
||||
if (name)
|
||||
mname = mono_string_to_utf8 (name);
|
||||
if (name) {
|
||||
mname = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
}
|
||||
|
||||
method_array = mono_class_get_methods_by_name (klass, mname, bflags, ignore_case, FALSE, &ex);
|
||||
g_free ((char*)mname);
|
||||
@@ -4237,7 +4244,9 @@ ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name,
|
||||
klass = startklass = mono_class_from_mono_type (type->type);
|
||||
|
||||
if (name != NULL) {
|
||||
propname = mono_string_to_utf8 (name);
|
||||
propname = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
|
||||
}
|
||||
|
||||
@@ -4426,7 +4435,9 @@ handle_parent:
|
||||
|
||||
if (name != NULL) {
|
||||
if (utf8_name == NULL) {
|
||||
utf8_name = mono_string_to_utf8 (name);
|
||||
utf8_name = mono_string_to_utf8_checked (name, &error);
|
||||
if (!is_ok (&error))
|
||||
goto failure;
|
||||
compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp;
|
||||
}
|
||||
|
||||
@@ -4534,7 +4545,9 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint
|
||||
|
||||
if (name != NULL) {
|
||||
if (str == NULL) {
|
||||
str = mono_string_to_utf8 (name);
|
||||
str = mono_string_to_utf8_checked (name, &error);
|
||||
if (!is_ok (&error))
|
||||
goto leave;
|
||||
mono_identifier_unescape_type_name_chars (str);
|
||||
}
|
||||
|
||||
@@ -4577,7 +4590,9 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as
|
||||
|
||||
/* On MS.NET, this does not fire a TypeResolve event */
|
||||
type_resolve = TRUE;
|
||||
str = mono_string_to_utf8 (name);
|
||||
str = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
/*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
|
||||
if (!mono_reflection_parse_type (str, &info)) {
|
||||
g_free (str);
|
||||
@@ -4790,7 +4805,9 @@ ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname,
|
||||
MonoImageOpenStatus status;
|
||||
MonoReflectionAssembly* result = NULL;
|
||||
|
||||
name = mono_string_to_utf8 (mname);
|
||||
name = mono_string_to_utf8_checked (mname, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
res = mono_assembly_load_with_partial_name (name, &status);
|
||||
|
||||
g_free (name);
|
||||
@@ -5037,7 +5054,6 @@ ICALL_EXPORT void *
|
||||
ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
|
||||
{
|
||||
MonoError error;
|
||||
char *n = mono_string_to_utf8 (name);
|
||||
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
|
||||
guint32 i;
|
||||
guint32 cols [MONO_MANIFEST_SIZE];
|
||||
@@ -5045,6 +5061,10 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflection
|
||||
const char *val;
|
||||
MonoImage *module;
|
||||
|
||||
char *n = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
|
||||
for (i = 0; i < table->rows; ++i) {
|
||||
mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
|
||||
val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
|
||||
@@ -5091,7 +5111,9 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflec
|
||||
const char *val;
|
||||
char *n;
|
||||
|
||||
n = mono_string_to_utf8 (name);
|
||||
n = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
for (i = 0; i < table->rows; ++i) {
|
||||
mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
|
||||
val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
|
||||
@@ -5163,7 +5185,10 @@ ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *a
|
||||
|
||||
/* check hash if needed */
|
||||
if (name) {
|
||||
n = mono_string_to_utf8 (name);
|
||||
n = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
|
||||
for (i = 0; i < table->rows; ++i) {
|
||||
val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
|
||||
if (strcmp (val, n) == 0) {
|
||||
@@ -5643,7 +5668,9 @@ ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname,
|
||||
MonoAssemblyName name;
|
||||
char *dirname;
|
||||
|
||||
filename = mono_string_to_utf8 (fname);
|
||||
filename = mono_string_to_utf8_checked (fname, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return;
|
||||
|
||||
dirname = g_path_get_dirname (filename);
|
||||
replace_shadow_path (mono_domain_get (), dirname, &filename);
|
||||
@@ -5904,7 +5931,10 @@ ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *
|
||||
gboolean is_token_defined;
|
||||
|
||||
aname.public_key = NULL;
|
||||
val = mono_string_to_utf8 (assname);
|
||||
val = mono_string_to_utf8_checked (assname, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
|
||||
if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined, &is_token_defined)) {
|
||||
g_free ((guint8*) aname.public_key);
|
||||
g_free (val);
|
||||
@@ -6368,8 +6398,10 @@ ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, Mon
|
||||
MonoReflectionType *ret;
|
||||
MonoClass *klass;
|
||||
int isbyref = 0, rank;
|
||||
char *str = mono_string_to_utf8 (smodifiers);
|
||||
char *p;
|
||||
char *str = mono_string_to_utf8_checked (smodifiers, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
|
||||
klass = mono_class_from_mono_type (tb->type.type);
|
||||
p = str;
|
||||
@@ -6867,13 +6899,16 @@ ves_icall_System_Environment_GetIs64BitOperatingSystem (void)
|
||||
ICALL_EXPORT MonoString *
|
||||
ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
|
||||
{
|
||||
MonoError error;
|
||||
const gchar *value;
|
||||
gchar *utf8_name;
|
||||
|
||||
if (name == NULL)
|
||||
return NULL;
|
||||
|
||||
utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
|
||||
utf8_name = mono_string_to_utf8_checked (name, &error); /* FIXME: this should be ascii */
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
value = g_getenv (utf8_name);
|
||||
|
||||
g_free (utf8_name);
|
||||
@@ -7034,7 +7069,9 @@ ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, M
|
||||
g_free (utf16_name);
|
||||
g_free (utf16_value);
|
||||
#else
|
||||
utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
|
||||
utf8_name = mono_string_to_utf8_checked (name, &error); /* FIXME: this should be ascii */
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return;
|
||||
|
||||
if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
|
||||
g_unsetenv (utf8_name);
|
||||
@@ -7522,6 +7559,7 @@ ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
|
||||
static MonoString *
|
||||
get_bundled_app_config (void)
|
||||
{
|
||||
MonoError error;
|
||||
const gchar *app_config;
|
||||
MonoDomain *domain;
|
||||
MonoString *file;
|
||||
@@ -7535,7 +7573,8 @@ get_bundled_app_config (void)
|
||||
return NULL;
|
||||
|
||||
// Retrieve config file and remove the extension
|
||||
config_file_name = mono_string_to_utf8 (file);
|
||||
config_file_name = mono_string_to_utf8_checked (file, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
config_file_path = mono_portability_find_file (config_file_name, TRUE);
|
||||
if (!config_file_path)
|
||||
config_file_path = config_file_name;
|
||||
|
||||
+10
-3
@@ -177,7 +177,9 @@ ves_icall_System_Globalization_CalendarData_fill_calendar_data (MonoCalendarData
|
||||
const CultureInfoEntry *ci;
|
||||
char *n;
|
||||
|
||||
n = mono_string_to_utf8 (name);
|
||||
n = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
ne = (const CultureInfoNameEntry *)mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
|
||||
sizeof (CultureInfoNameEntry), culture_name_locator);
|
||||
g_free (n);
|
||||
@@ -574,7 +576,9 @@ ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_name (
|
||||
const CultureInfoNameEntry *ne;
|
||||
char *n;
|
||||
|
||||
n = mono_string_to_utf8 (name);
|
||||
n = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
ne = (const CultureInfoNameEntry *)mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
|
||||
sizeof (CultureInfoNameEntry), culture_name_locator);
|
||||
|
||||
@@ -623,10 +627,13 @@ MonoBoolean
|
||||
ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_name (MonoRegionInfo *this_obj,
|
||||
MonoString *name)
|
||||
{
|
||||
MonoError error;
|
||||
const RegionInfoNameEntry *ne;
|
||||
char *n;
|
||||
|
||||
n = mono_string_to_utf8 (name);
|
||||
n = mono_string_to_utf8_checked (name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
ne = (const RegionInfoNameEntry *)mono_binary_search (n, region_name_entries, NUM_REGION_ENTRIES,
|
||||
sizeof (RegionInfoNameEntry), region_name_locator);
|
||||
|
||||
|
||||
+39
-12
@@ -266,6 +266,15 @@ ves_icall_mono_string_from_utf16 (gunichar2 *data)
|
||||
return result;
|
||||
}
|
||||
|
||||
static char*
|
||||
ves_icall_mono_string_to_utf8 (MonoString *str)
|
||||
{
|
||||
MonoError error;
|
||||
char *result = mono_string_to_utf8_checked (str, &error);
|
||||
mono_error_set_pending_exception (&error);
|
||||
return result;
|
||||
}
|
||||
|
||||
void
|
||||
mono_marshal_init (void)
|
||||
{
|
||||
@@ -285,7 +294,7 @@ mono_marshal_init (void)
|
||||
register_icall (mono_string_from_byvalwstr, "mono_string_from_byvalwstr", "obj ptr int", FALSE);
|
||||
register_icall (mono_string_new_wrapper, "mono_string_new_wrapper", "obj ptr", FALSE);
|
||||
register_icall (mono_string_new_len_wrapper, "mono_string_new_len_wrapper", "obj ptr int", FALSE);
|
||||
register_icall (mono_string_to_utf8, "mono_string_to_utf8", "ptr obj", FALSE);
|
||||
register_icall (ves_icall_mono_string_to_utf8, "ves_icall_mono_string_to_utf8", "ptr obj", FALSE);
|
||||
register_icall (mono_string_to_lpstr, "mono_string_to_lpstr", "ptr obj", FALSE);
|
||||
register_icall (mono_string_to_ansibstr, "mono_string_to_ansibstr", "ptr object", FALSE);
|
||||
register_icall (mono_string_builder_to_utf8, "mono_string_builder_to_utf8", "ptr object", FALSE);
|
||||
@@ -1084,7 +1093,10 @@ mono_string_to_lpstr (MonoString *s)
|
||||
return as;
|
||||
}
|
||||
#else
|
||||
return mono_string_to_utf8 (s);
|
||||
MonoError error;
|
||||
char *result = mono_string_to_utf8_checked (s, &error);
|
||||
mono_error_set_pending_exception (&error);
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -1107,6 +1119,7 @@ mono_string_to_ansibstr (MonoString *string_obj)
|
||||
void
|
||||
mono_string_to_byvalstr (gpointer dst, MonoString *src, int size)
|
||||
{
|
||||
MonoError error;
|
||||
char *s;
|
||||
int len;
|
||||
|
||||
@@ -1117,7 +1130,9 @@ mono_string_to_byvalstr (gpointer dst, MonoString *src, int size)
|
||||
if (!src)
|
||||
return;
|
||||
|
||||
s = mono_string_to_utf8 (src);
|
||||
s = mono_string_to_utf8_checked (src, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return;
|
||||
len = MIN (size, strlen (s));
|
||||
if (len >= size)
|
||||
len--;
|
||||
@@ -3012,12 +3027,16 @@ mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params)
|
||||
|
||||
if (exc) {
|
||||
if (((MonoException*)exc)->stack_trace) {
|
||||
char *strace = mono_string_to_utf8 (((MonoException*)exc)->stack_trace);
|
||||
char *tmp;
|
||||
tmp = g_strdup_printf ("%s\nException Rethrown at:\n", strace);
|
||||
g_free (strace);
|
||||
MONO_OBJECT_SETREF (((MonoException*)exc), stack_trace, mono_string_new (domain, tmp));
|
||||
g_free (tmp);
|
||||
MonoError inner_error;
|
||||
char *strace = mono_string_to_utf8_checked (((MonoException*)exc)->stack_trace, &inner_error);
|
||||
if (is_ok (&inner_error)) {
|
||||
char *tmp;
|
||||
tmp = g_strdup_printf ("%s\nException Rethrown at:\n", strace);
|
||||
g_free (strace);
|
||||
MONO_OBJECT_SETREF (((MonoException*)exc), stack_trace, mono_string_new (domain, tmp));
|
||||
g_free (tmp);
|
||||
} else
|
||||
mono_error_cleanup (&inner_error); /* no stack trace, but at least throw the original exception */
|
||||
}
|
||||
mono_set_pending_exception ((MonoException*)exc);
|
||||
}
|
||||
@@ -10774,6 +10793,7 @@ ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer s
|
||||
int
|
||||
ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name)
|
||||
{
|
||||
MonoError error;
|
||||
MonoMarshalType *info;
|
||||
MonoClass *klass;
|
||||
char *fname;
|
||||
@@ -10782,7 +10802,9 @@ ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *t
|
||||
MONO_CHECK_ARG_NULL (type, 0);
|
||||
MONO_CHECK_ARG_NULL (field_name, 0);
|
||||
|
||||
fname = mono_string_to_utf8 (field_name);
|
||||
fname = mono_string_to_utf8_checked (field_name, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return 0;
|
||||
klass = mono_class_from_mono_type (type->type);
|
||||
if (!mono_class_init (klass)) {
|
||||
mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
|
||||
@@ -10831,10 +10853,13 @@ ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *t
|
||||
gpointer
|
||||
ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string)
|
||||
{
|
||||
MonoError error;
|
||||
#ifdef HOST_WIN32
|
||||
char* tres, *ret;
|
||||
size_t len;
|
||||
tres = mono_string_to_utf8 (string);
|
||||
tres = mono_string_to_utf8_checked (string, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return NULL;
|
||||
if (!tres)
|
||||
return tres;
|
||||
|
||||
@@ -10845,7 +10870,9 @@ ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString
|
||||
return ret;
|
||||
|
||||
#else
|
||||
return mono_string_to_utf8 (string);
|
||||
char *ret = mono_string_to_utf8_checked (string, &error);
|
||||
mono_error_set_pending_exception (&error);
|
||||
return ret;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@@ -804,9 +804,11 @@ fill_sample (MonoCounterSample *sample)
|
||||
static int
|
||||
id_from_string (MonoString *instance, gboolean is_process)
|
||||
{
|
||||
MonoError error;
|
||||
int id = -1;
|
||||
if (mono_string_length (instance)) {
|
||||
char *id_str = mono_string_to_utf8 (instance);
|
||||
char *id_str = mono_string_to_utf8_checked (instance, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
char *end;
|
||||
id = strtol (id_str, &end, 0);
|
||||
if (end == id_str && !is_process)
|
||||
@@ -912,6 +914,7 @@ network_cleanup (ImplVtable *vtable)
|
||||
static void*
|
||||
network_get_impl (MonoString* counter, MonoString* instance, int *type, MonoBoolean *custom)
|
||||
{
|
||||
MonoError error;
|
||||
const CounterDesc *cdesc;
|
||||
NetworkVtableArg *narg;
|
||||
ImplVtable *vtable;
|
||||
@@ -919,7 +922,8 @@ network_get_impl (MonoString* counter, MonoString* instance, int *type, MonoBool
|
||||
|
||||
*custom = FALSE;
|
||||
if ((cdesc = get_counter_in_category (&predef_categories [CATEGORY_NETWORK], counter))) {
|
||||
instance_name = mono_string_to_utf8 (instance);
|
||||
instance_name = mono_string_to_utf8_checked (instance, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
narg = g_new0 (NetworkVtableArg, 1);
|
||||
narg->id = cdesc->id;
|
||||
narg->name = instance_name;
|
||||
@@ -1043,9 +1047,11 @@ predef_readonly_counter (ImplVtable *vtable, MonoBoolean only_value, MonoCounter
|
||||
static ImplVtable*
|
||||
predef_vtable (void *arg, MonoString *instance)
|
||||
{
|
||||
MonoError error;
|
||||
MonoSharedArea *area;
|
||||
PredefVtable *vtable;
|
||||
char *pids = mono_string_to_utf8 (instance);
|
||||
char *pids = mono_string_to_utf8_checked (instance, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
int pid;
|
||||
|
||||
pid = atoi (pids);
|
||||
@@ -1300,6 +1306,7 @@ custom_get_value_address (SharedCounter *scounter, SharedInstance* sinst)
|
||||
static void*
|
||||
custom_get_impl (SharedCategory *cat, MonoString* counter, MonoString* instance, int *type)
|
||||
{
|
||||
MonoError error;
|
||||
SharedCounter *scounter;
|
||||
SharedInstance* inst;
|
||||
char *name;
|
||||
@@ -1308,7 +1315,8 @@ custom_get_impl (SharedCategory *cat, MonoString* counter, MonoString* instance,
|
||||
if (!scounter)
|
||||
return NULL;
|
||||
*type = simple_type_to_type [scounter->type];
|
||||
name = mono_string_to_utf8 (counter);
|
||||
name = mono_string_to_utf8_checked (counter, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
inst = custom_get_instance (cat, scounter, name);
|
||||
g_free (name);
|
||||
if (!inst)
|
||||
@@ -1490,7 +1498,6 @@ mono_perfcounter_create (MonoString *category, MonoString *help, int type, MonoA
|
||||
SharedCategory *cat;
|
||||
|
||||
/* FIXME: ensure there isn't a category created already */
|
||||
mono_error_init (&error);
|
||||
name = mono_string_to_utf8_checked (category, &error);
|
||||
if (!mono_error_ok (&error))
|
||||
goto failure;
|
||||
@@ -1563,6 +1570,7 @@ failure:
|
||||
int
|
||||
mono_perfcounter_instance_exists (MonoString *instance, MonoString *category, MonoString *machine)
|
||||
{
|
||||
MonoError error;
|
||||
const CategoryDesc *cdesc;
|
||||
SharedInstance *sinst;
|
||||
char *name;
|
||||
@@ -1576,7 +1584,8 @@ mono_perfcounter_instance_exists (MonoString *instance, MonoString *category, Mo
|
||||
scat = find_custom_category (category);
|
||||
if (!scat)
|
||||
return FALSE;
|
||||
name = mono_string_to_utf8 (instance);
|
||||
name = mono_string_to_utf8_checked (instance, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
sinst = find_custom_instance (scat, name);
|
||||
g_free (name);
|
||||
if (sinst)
|
||||
|
||||
@@ -21,6 +21,7 @@
|
||||
|
||||
extern MonoBoolean ves_icall_System_Net_NetworkInformation_MacOsIPInterfaceProperties_ParseRouteInfo_internal(MonoString *iface, MonoArray **gw_addr_list)
|
||||
{
|
||||
MonoError error;
|
||||
size_t needed;
|
||||
in_addr_t in;
|
||||
int mib[6];
|
||||
@@ -31,7 +32,10 @@ extern MonoBoolean ves_icall_System_Net_NetworkInformation_MacOsIPInterfacePrope
|
||||
|
||||
MonoDomain *domain = mono_domain_get ();
|
||||
|
||||
ifacename = mono_string_to_utf8(iface);
|
||||
ifacename = mono_string_to_utf8_checked(iface, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
|
||||
if ((ifindex = if_nametoindex(ifacename)) == 0)
|
||||
return FALSE;
|
||||
g_free(ifacename);
|
||||
|
||||
@@ -6833,8 +6833,10 @@ mono_string_to_utf8 (MonoString *s)
|
||||
MonoError error;
|
||||
char *result = mono_string_to_utf8_checked (s, &error);
|
||||
|
||||
if (!mono_error_ok (&error))
|
||||
mono_error_raise_exception (&error);
|
||||
if (!is_ok (&error)) {
|
||||
mono_error_cleanup (&error);
|
||||
return NULL;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
@@ -145,6 +145,7 @@ MONO_RT_EXTERNAL_ONLY
|
||||
MONO_API MonoString*
|
||||
mono_string_new_utf32 (MonoDomain *domain, const mono_unichar4 *text, int32_t len);
|
||||
|
||||
MONO_RT_EXTERNAL_ONLY
|
||||
MONO_API char *
|
||||
mono_string_to_utf8 (MonoString *string_obj);
|
||||
|
||||
|
||||
@@ -693,6 +693,7 @@ ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoProcessStartIn
|
||||
MonoBoolean
|
||||
ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoProcessStartInfo *proc_start_info, HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoProcInfo *process_info)
|
||||
{
|
||||
MonoError error G_GNUC_UNUSED;
|
||||
gboolean ret;
|
||||
gunichar2 *dir;
|
||||
STARTUPINFO startinfo={0};
|
||||
@@ -727,7 +728,11 @@ ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoProcessStartInf
|
||||
free_shell_path = FALSE;
|
||||
if (cmd) {
|
||||
gchar *newcmd, *tmp;
|
||||
tmp = mono_string_to_utf8 (cmd);
|
||||
tmp = mono_string_to_utf8_checked (cmd, &error);
|
||||
if (mono_error_set_pending_exception (&error)) {
|
||||
g_free (spath);
|
||||
return NULL;
|
||||
}
|
||||
newcmd = g_strdup_printf ("%s %s", spath, tmp);
|
||||
cmd = mono_string_new_wrapper (newcmd);
|
||||
g_free (tmp);
|
||||
|
||||
+92
-34
@@ -531,7 +531,9 @@ string_heap_insert_mstring (MonoDynamicStream *sh, MonoString *str)
|
||||
{
|
||||
MONO_REQ_GC_UNSAFE_MODE;
|
||||
|
||||
char *name = mono_string_to_utf8 (str);
|
||||
MonoError error;
|
||||
char *name = mono_string_to_utf8_checked (str, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
guint32 idx;
|
||||
idx = string_heap_insert (sh, name);
|
||||
g_free (name);
|
||||
@@ -1264,7 +1266,12 @@ method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb, Mon
|
||||
} else {
|
||||
code = mb->code;
|
||||
if (code == NULL){
|
||||
char *name = mono_string_to_utf8 (mb->name);
|
||||
MonoError inner_error;
|
||||
char *name = mono_string_to_utf8_checked (mb->name, &inner_error);
|
||||
if (!is_ok (&inner_error)) {
|
||||
name = g_strdup ("");
|
||||
mono_error_cleanup (&inner_error);
|
||||
}
|
||||
char *str = g_strdup_printf ("Method %s does not have any IL associated", name);
|
||||
mono_error_set_argument (error, NULL, "a method does not have any IL associated");
|
||||
g_free (str);
|
||||
@@ -2233,7 +2240,11 @@ encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, M
|
||||
break;
|
||||
case MONO_NATIVE_CUSTOM:
|
||||
if (minfo->guid) {
|
||||
str = mono_string_to_utf8 (minfo->guid);
|
||||
str = mono_string_to_utf8_checked (minfo->guid, error);
|
||||
if (!is_ok (error)) {
|
||||
sigbuffer_free (&buf);
|
||||
return 0;
|
||||
}
|
||||
len = strlen (str);
|
||||
sigbuffer_add_value (&buf, len);
|
||||
sigbuffer_add_mem (&buf, str, len);
|
||||
@@ -2252,8 +2263,13 @@ encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, M
|
||||
return 0;
|
||||
}
|
||||
str = type_get_fully_qualified_name (marshaltype);
|
||||
} else
|
||||
str = mono_string_to_utf8 (minfo->marshaltype);
|
||||
} else {
|
||||
str = mono_string_to_utf8_checked (minfo->marshaltype, error);
|
||||
if (!is_ok (error)) {
|
||||
sigbuffer_free (&buf);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
len = strlen (str);
|
||||
sigbuffer_add_value (&buf, len);
|
||||
sigbuffer_add_mem (&buf, str, len);
|
||||
@@ -2263,7 +2279,11 @@ encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, M
|
||||
sigbuffer_add_value (&buf, 0);
|
||||
}
|
||||
if (minfo->mcookie) {
|
||||
str = mono_string_to_utf8 (minfo->mcookie);
|
||||
str = mono_string_to_utf8_checked (minfo->mcookie, error);
|
||||
if (!is_ok (error)) {
|
||||
sigbuffer_free (&buf);
|
||||
return 0;
|
||||
}
|
||||
len = strlen (str);
|
||||
sigbuffer_add_value (&buf, len);
|
||||
sigbuffer_add_mem (&buf, str, len);
|
||||
@@ -2977,7 +2997,8 @@ mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, Mo
|
||||
parent = mono_image_typedef_or_ref (assembly, t);
|
||||
}
|
||||
|
||||
char *name = mono_string_to_utf8 (method->name);
|
||||
char *name = mono_string_to_utf8_checked (method->name, error);
|
||||
return_val_if_nok (error, 0);
|
||||
|
||||
token = mono_image_add_memberef_row (assembly, parent, name, sig);
|
||||
g_free (name);
|
||||
@@ -3127,7 +3148,8 @@ mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtor
|
||||
parent = mono_image_typedef_or_ref (assembly, type);
|
||||
}
|
||||
|
||||
name = mono_string_to_utf8 (rmb.name);
|
||||
name = mono_string_to_utf8_checked (rmb.name, error);
|
||||
return_val_if_nok (error, 0);
|
||||
sig = method_builder_encode_signature (assembly, &rmb, error);
|
||||
return_val_if_nok (error, 0);
|
||||
|
||||
@@ -3228,7 +3250,8 @@ mono_image_get_field_on_inst_token (MonoDynamicImage *assembly, MonoReflectionFi
|
||||
|
||||
guint32 sig_token = field_encode_signature (assembly, fb, error);
|
||||
return_val_if_nok (error, 0);
|
||||
name = mono_string_to_utf8 (fb->name);
|
||||
name = mono_string_to_utf8_checked (fb->name, error);
|
||||
return_val_if_nok (error, 0);
|
||||
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig_token);
|
||||
g_free (name);
|
||||
} else if (is_sr_mono_field (mono_object_class (f->fb))) {
|
||||
@@ -3284,7 +3307,8 @@ mono_image_get_ctor_on_inst_token (MonoDynamicImage *assembly, MonoReflectionCto
|
||||
sig = method_builder_encode_signature (assembly, &rmb, error);
|
||||
return_val_if_nok (error, 0);
|
||||
|
||||
name = mono_string_to_utf8 (rmb.name);
|
||||
name = mono_string_to_utf8_checked (rmb.name, error);
|
||||
return_val_if_nok (error, 0);
|
||||
|
||||
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
|
||||
g_free (name);
|
||||
@@ -3396,7 +3420,8 @@ mono_image_get_method_on_inst_token (MonoDynamicImage *assembly, MonoReflectionM
|
||||
sig = method_builder_encode_signature (assembly, &rmb, error);
|
||||
return_val_if_nok (error, 0);
|
||||
|
||||
name = mono_string_to_utf8 (rmb.name);
|
||||
name = mono_string_to_utf8_checked (rmb.name, error);
|
||||
return_val_if_nok (error, 0);
|
||||
|
||||
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
|
||||
g_free (name);
|
||||
@@ -3713,7 +3738,8 @@ mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFi
|
||||
|
||||
table = &assembly->tables [MONO_TABLE_MEMBERREF];
|
||||
|
||||
name = mono_string_to_utf8 (fb->name);
|
||||
name = mono_string_to_utf8_checked (fb->name, error);
|
||||
return_val_if_nok (error, 0);
|
||||
|
||||
if (assembly->save) {
|
||||
alloc_table (table, table->rows + 1);
|
||||
@@ -3879,7 +3905,9 @@ mono_image_get_array_token (MonoDynamicImage *assembly, MonoReflectionArrayMetho
|
||||
goto fail;
|
||||
}
|
||||
|
||||
name = mono_string_to_utf8 (m->name);
|
||||
name = mono_string_to_utf8_checked (m->name, error);
|
||||
if (!is_ok (error))
|
||||
goto fail;
|
||||
for (tmp = assembly->array_methods; tmp; tmp = tmp->next) {
|
||||
am = (ArrayMethod *)tmp->data;
|
||||
if (strcmp (name, am->name) == 0 &&
|
||||
@@ -3925,12 +3953,14 @@ mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, Mon
|
||||
table = &assembly->tables [MONO_TABLE_TYPEDEF];
|
||||
values = table->values + tb->table_idx * MONO_TYPEDEF_SIZE;
|
||||
values [MONO_TYPEDEF_FLAGS] = tb->attrs;
|
||||
n = mono_string_to_utf8 (tb->name);
|
||||
n = mono_string_to_utf8_checked (tb->name, error);
|
||||
return_val_if_nok (error, FALSE);
|
||||
if (strcmp (n, "Object") == 0)
|
||||
is_object++;
|
||||
values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, n);
|
||||
g_free (n);
|
||||
n = mono_string_to_utf8 (tb->nspace);
|
||||
n = mono_string_to_utf8_checked (tb->nspace, error);
|
||||
return_val_if_nok (error, FALSE);
|
||||
if (strcmp (n, "System") == 0)
|
||||
is_system++;
|
||||
values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, n);
|
||||
@@ -4240,6 +4270,7 @@ module_add_cattrs (MonoDynamicImage *assembly, MonoReflectionModuleBuilder *modu
|
||||
static void
|
||||
mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly)
|
||||
{
|
||||
MonoError error;
|
||||
MonoDynamicTable *table;
|
||||
guint32 *values;
|
||||
char blob_size [6];
|
||||
@@ -4255,7 +4286,8 @@ mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, Mo
|
||||
values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, module->image->module_name);
|
||||
if (image_is_dynamic (module->image)) {
|
||||
/* This depends on the fact that the main module is emitted last */
|
||||
dir = mono_string_to_utf8 (((MonoReflectionModuleBuilder*)module)->assemblyb->dir);
|
||||
dir = mono_string_to_utf8_checked (((MonoReflectionModuleBuilder*)module)->assemblyb->dir, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
path = g_strdup_printf ("%s%c%s", dir, G_DIR_SEPARATOR, module->image->module_name);
|
||||
} else {
|
||||
dir = NULL;
|
||||
@@ -4957,6 +4989,7 @@ assembly_add_resource_manifest (MonoReflectionModuleBuilder *mb, MonoDynamicImag
|
||||
static void
|
||||
assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc)
|
||||
{
|
||||
MonoError error;
|
||||
MonoDynamicTable *table;
|
||||
guint32 *values;
|
||||
char blob_size [6];
|
||||
@@ -4966,7 +4999,8 @@ assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assemb
|
||||
guint32 idx, offset;
|
||||
|
||||
if (rsrc->filename) {
|
||||
name = mono_string_to_utf8 (rsrc->filename);
|
||||
name = mono_string_to_utf8_checked (rsrc->filename, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
sname = g_path_get_basename (name);
|
||||
|
||||
table = &assembly->tables [MONO_TABLE_FILE];
|
||||
@@ -5019,6 +5053,7 @@ assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assemb
|
||||
static void
|
||||
set_version_from_string (MonoString *version, guint32 *values)
|
||||
{
|
||||
MonoError error;
|
||||
gchar *ver, *p, *str;
|
||||
guint32 i;
|
||||
|
||||
@@ -5028,7 +5063,8 @@ set_version_from_string (MonoString *version, guint32 *values)
|
||||
values [MONO_ASSEMBLY_BUILD_NUMBER] = 0;
|
||||
if (!version)
|
||||
return;
|
||||
ver = str = mono_string_to_utf8 (version);
|
||||
ver = str = mono_string_to_utf8_checked (version, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
for (i = 0; i < 4; ++i) {
|
||||
values [MONO_ASSEMBLY_MAJOR_VERSION + i] = strtol (ver, &p, 10);
|
||||
switch (*p) {
|
||||
@@ -5501,7 +5537,8 @@ mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, Mon
|
||||
parent = mono_metadata_token_index (parent) << MONO_MEMBERREF_PARENT_BITS;
|
||||
parent |= MONO_MEMBERREF_PARENT_METHODDEF;
|
||||
|
||||
char *name = mono_string_to_utf8 (rmb.name);
|
||||
char *name = mono_string_to_utf8_checked (rmb.name, error);
|
||||
if (!is_ok (error)) goto fail;
|
||||
token = mono_image_get_varargs_method_token (
|
||||
assembly, parent, name, sig_token);
|
||||
g_free (name);
|
||||
@@ -5950,6 +5987,7 @@ mono_dynamic_image_free_image (MonoDynamicImage *image)
|
||||
void
|
||||
mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
|
||||
{
|
||||
MonoError error;
|
||||
MonoDynamicAssembly *assembly;
|
||||
MonoDynamicImage *image;
|
||||
MonoDomain *domain = mono_object_domain (assemblyb);
|
||||
@@ -5970,14 +6008,17 @@ mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
|
||||
assembly->assembly.dynamic = TRUE;
|
||||
assembly->assembly.corlib_internal = assemblyb->corlib_internal;
|
||||
assemblyb->assembly.assembly = (MonoAssembly*)assembly;
|
||||
assembly->assembly.basedir = mono_string_to_utf8 (assemblyb->dir);
|
||||
if (assemblyb->culture)
|
||||
assembly->assembly.aname.culture = mono_string_to_utf8 (assemblyb->culture);
|
||||
else
|
||||
assembly->assembly.basedir = mono_string_to_utf8_checked (assemblyb->dir, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
if (assemblyb->culture) {
|
||||
assembly->assembly.aname.culture = mono_string_to_utf8_checked (assemblyb->culture, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
} else
|
||||
assembly->assembly.aname.culture = g_strdup ("");
|
||||
|
||||
if (assemblyb->version) {
|
||||
char *vstr = mono_string_to_utf8 (assemblyb->version);
|
||||
char *vstr = mono_string_to_utf8_checked (assemblyb->version, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
char **version = g_strsplit (vstr, ".", 4);
|
||||
char **parts = version;
|
||||
assembly->assembly.aname.major = atoi (*parts++);
|
||||
@@ -5998,7 +6039,9 @@ mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
|
||||
assembly->save = assemblyb->access != 1;
|
||||
assembly->domain = domain;
|
||||
|
||||
image = create_dynamic_mono_image (assembly, mono_string_to_utf8 (assemblyb->name), g_strdup ("RefEmit_YouForgotToDefineAModule"));
|
||||
char *assembly_name = mono_string_to_utf8_checked (assemblyb->name, &error);
|
||||
mono_error_raise_exception (&error); /* FIXME don't raise here */
|
||||
image = create_dynamic_mono_image (assembly, assembly_name, g_strdup ("RefEmit_YouForgotToDefineAModule"));
|
||||
image->initial_image = TRUE;
|
||||
assembly->assembly.aname.name = image->image.name;
|
||||
assembly->assembly.image = &image->image;
|
||||
@@ -6691,7 +6734,8 @@ mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *ab, MonoString *f
|
||||
|
||||
mono_error_init (error);
|
||||
|
||||
name = mono_string_to_utf8 (fileName);
|
||||
name = mono_string_to_utf8_checked (fileName, error);
|
||||
return_val_if_nok (error, NULL);
|
||||
|
||||
image = mono_image_open (name, &status);
|
||||
if (!image) {
|
||||
@@ -6879,7 +6923,8 @@ image_module_basic_init (MonoReflectionModuleBuilder *moduleb, MonoError *error)
|
||||
* determined at assembly save time.
|
||||
*/
|
||||
/*image = (MonoDynamicImage*)ab->dynamic_assembly->assembly.image; */
|
||||
name = mono_string_to_utf8 (ab->name);
|
||||
name = mono_string_to_utf8_checked (ab->name, error);
|
||||
return_val_if_nok (error, FALSE);
|
||||
fqname = mono_string_to_utf8_checked (moduleb->module.fqname, error);
|
||||
if (!is_ok (error)) {
|
||||
g_free (name);
|
||||
@@ -10867,7 +10912,8 @@ get_prop_name_and_type (MonoObject *prop, char **name, MonoType **type, MonoErro
|
||||
MonoClass *klass = mono_object_class (prop);
|
||||
if (strcmp (klass->name, "PropertyBuilder") == 0) {
|
||||
MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
|
||||
*name = mono_string_to_utf8 (pb->name);
|
||||
*name = mono_string_to_utf8_checked (pb->name, error);
|
||||
return_if_nok (error);
|
||||
*type = mono_reflection_type_get_handle ((MonoReflectionType*)pb->type, error);
|
||||
} else {
|
||||
MonoReflectionProperty *p = (MonoReflectionProperty *)prop;
|
||||
@@ -10886,7 +10932,8 @@ get_field_name_and_type (MonoObject *field, char **name, MonoType **type, MonoEr
|
||||
MonoClass *klass = mono_object_class (field);
|
||||
if (strcmp (klass->name, "FieldBuilder") == 0) {
|
||||
MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
|
||||
*name = mono_string_to_utf8 (fb->name);
|
||||
*name = mono_string_to_utf8_checked (fb->name, error);
|
||||
return_if_nok (error);
|
||||
*type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
|
||||
} else {
|
||||
MonoReflectionField *f = (MonoReflectionField *)field;
|
||||
@@ -11064,7 +11111,8 @@ handle_enum:
|
||||
*p++ = 0xFF;
|
||||
break;
|
||||
}
|
||||
str = mono_string_to_utf8 ((MonoString*)arg);
|
||||
str = mono_string_to_utf8_checked ((MonoString*)arg, error);
|
||||
return_if_nok (error);
|
||||
slen = strlen (str);
|
||||
if ((p-buffer) + 10 + slen >= *buflen) {
|
||||
char *newbuf;
|
||||
@@ -11763,8 +11811,13 @@ mono_marshal_spec_from_builder (MonoImage *image, MonoAssembly *assembly,
|
||||
res->data.custom_data.custom_name =
|
||||
type_get_fully_qualified_name (marshaltyperef);
|
||||
}
|
||||
if (minfo->mcookie)
|
||||
res->data.custom_data.cookie = mono_string_to_utf8 (minfo->mcookie);
|
||||
if (minfo->mcookie) {
|
||||
res->data.custom_data.cookie = mono_string_to_utf8_checked (minfo->mcookie, error);
|
||||
if (!is_ok (error)) {
|
||||
image_g_free (image, res);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -13034,7 +13087,11 @@ reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoRefl
|
||||
|
||||
event->parent = klass;
|
||||
event->attrs = eb->attrs;
|
||||
event->name = mono_string_to_utf8 (eb->name);
|
||||
event->name = mono_string_to_utf8_checked (eb->name, error);
|
||||
if (!is_ok (error)) {
|
||||
g_free (event);
|
||||
return NULL;
|
||||
}
|
||||
if (eb->add_method)
|
||||
event->add = eb->add_method->mhandle;
|
||||
if (eb->remove_method)
|
||||
@@ -14142,7 +14199,8 @@ resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, Mon
|
||||
|
||||
/* Find the method */
|
||||
|
||||
name = mono_string_to_utf8 (m->name);
|
||||
name = mono_string_to_utf8_checked (m->name, error);
|
||||
return_val_if_nok (error, NULL);
|
||||
iter = NULL;
|
||||
while ((method = mono_class_get_methods (klass, &iter))) {
|
||||
if (!strcmp (method->name, name))
|
||||
|
||||
@@ -2647,13 +2647,16 @@ get_addrinfo_family_hint (MonoError *error)
|
||||
MonoBoolean
|
||||
ves_icall_System_Net_Dns_GetHostByName_internal (MonoString *host, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list)
|
||||
{
|
||||
MonoError error;
|
||||
gboolean add_local_ips = FALSE, add_info_ok = TRUE;
|
||||
gchar this_hostname [256];
|
||||
MonoAddressInfo *info = NULL;
|
||||
char *hostname = mono_string_to_utf8 (host);
|
||||
MonoError error;
|
||||
int hint;
|
||||
|
||||
char *hostname = mono_string_to_utf8_checked (host, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
|
||||
hint = get_addrinfo_family_hint (&error);
|
||||
if (!mono_error_ok (&error)) {
|
||||
mono_error_set_pending_exception (&error);
|
||||
@@ -2697,7 +2700,9 @@ ves_icall_System_Net_Dns_GetHostByAddr_internal (MonoString *addr, MonoString **
|
||||
gchar hostname [NI_MAXHOST] = { 0 };
|
||||
gboolean ret;
|
||||
|
||||
address = mono_string_to_utf8 (addr);
|
||||
address = mono_string_to_utf8_checked (addr, &error);
|
||||
if (mono_error_set_pending_exception (&error))
|
||||
return FALSE;
|
||||
|
||||
if (inet_pton (AF_INET, address, &saddr.sin_addr ) == 1) {
|
||||
family = AF_INET;
|
||||
|
||||
@@ -1386,7 +1386,8 @@ mono_thread_set_name_internal (MonoInternalThread *this_obj, MonoString *name, g
|
||||
UNLOCK_THREAD (this_obj);
|
||||
|
||||
if (this_obj->name && this_obj->tid) {
|
||||
char *tname = mono_string_to_utf8 (name);
|
||||
char *tname = mono_string_to_utf8_checked (name, error);
|
||||
return_if_nok (error);
|
||||
mono_profiler_thread_name (this_obj->tid, tname);
|
||||
mono_native_thread_set_name (thread_get_tid (this_obj), tname);
|
||||
mono_free (tname);
|
||||
|
||||
@@ -5430,6 +5430,7 @@ ss_clear_for_assembly (SingleStepReq *req, MonoAssembly *assembly)
|
||||
void
|
||||
mono_debugger_agent_debug_log (int level, MonoString *category, MonoString *message)
|
||||
{
|
||||
MonoError error;
|
||||
int suspend_policy;
|
||||
GSList *events;
|
||||
EventInfo ei;
|
||||
@@ -5442,8 +5443,16 @@ mono_debugger_agent_debug_log (int level, MonoString *category, MonoString *mess
|
||||
mono_loader_unlock ();
|
||||
|
||||
ei.level = level;
|
||||
ei.category = category ? mono_string_to_utf8 (category) : NULL;
|
||||
ei.message = message ? mono_string_to_utf8 (message) : NULL;
|
||||
ei.category = NULL;
|
||||
if (category) {
|
||||
ei.category = mono_string_to_utf8_checked (category, &error);
|
||||
mono_error_cleanup (&error);
|
||||
}
|
||||
ei.message = NULL;
|
||||
if (message) {
|
||||
ei.message = mono_string_to_utf8_checked (message, &error);
|
||||
mono_error_cleanup (&error);
|
||||
}
|
||||
|
||||
process_event (EVENT_KIND_USER_LOG, &ei, 0, NULL, events, suspend_policy);
|
||||
|
||||
@@ -8676,7 +8685,8 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g
|
||||
s = mono_ldstr_checked (domain, method->klass->image, mono_metadata_token_index (token), &error);
|
||||
mono_error_assert_ok (&error); /* FIXME don't swallow the error */
|
||||
|
||||
s2 = mono_string_to_utf8 (s);
|
||||
s2 = mono_string_to_utf8_checked (s, &error);
|
||||
mono_error_assert_ok (&error);
|
||||
|
||||
buffer_add_byte (buf, TOKEN_TYPE_STRING);
|
||||
buffer_add_string (buf, s2);
|
||||
@@ -8684,6 +8694,7 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
MonoError error;
|
||||
gpointer val;
|
||||
MonoClass *handle_class;
|
||||
|
||||
@@ -8697,7 +8708,6 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
MonoError error;
|
||||
val = mono_ldtoken_checked (method->klass->image, token, &handle_class, NULL, &error);
|
||||
if (!val)
|
||||
g_error ("Could not load token due to %s", mono_error_get_message (&error));
|
||||
@@ -8718,7 +8728,8 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g
|
||||
} else if (handle_class == mono_defaults.string_class) {
|
||||
char *s;
|
||||
|
||||
s = mono_string_to_utf8 ((MonoString *)val);
|
||||
s = mono_string_to_utf8_checked ((MonoString *)val, &error);
|
||||
mono_error_assert_ok (&error);
|
||||
buffer_add_byte (buf, TOKEN_TYPE_STRING);
|
||||
buffer_add_string (buf, s);
|
||||
g_free (s);
|
||||
@@ -9234,7 +9245,9 @@ string_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
|
||||
buffer_add_int (buf, mono_string_length (str) * 2);
|
||||
buffer_add_data (buf, (guint8*)mono_string_chars (str), mono_string_length (str) * 2);
|
||||
} else {
|
||||
s = mono_string_to_utf8 (str);
|
||||
MonoError error;
|
||||
s = mono_string_to_utf8_checked (str, &error);
|
||||
mono_error_assert_ok (&error);
|
||||
buffer_add_string (buf, s);
|
||||
g_free (s);
|
||||
}
|
||||
|
||||
@@ -6834,7 +6834,8 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign
|
||||
MONO_INST_NEW (cfg, ins, OP_OBJC_GET_SELECTOR);
|
||||
ins->dreg = mono_alloc_ireg (cfg);
|
||||
// FIXME: Leaks
|
||||
ins->inst_p0 = mono_string_to_utf8 (s);
|
||||
ins->inst_p0 = mono_string_to_utf8_checked (s, &cfg->error);
|
||||
return_val_if_nok (&cfg->error, NULL);
|
||||
MONO_ADD_INS (cfg->cbb, ins);
|
||||
return ins;
|
||||
}
|
||||
|
||||
@@ -1697,7 +1697,15 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu
|
||||
mono_error_assert_ok (&error);
|
||||
}
|
||||
if (msg == NULL) {
|
||||
msg = message ? mono_string_to_utf8 ((MonoString *) message) : g_strdup ("(System.Exception.Message property not available)");
|
||||
if (message) {
|
||||
msg = mono_string_to_utf8_checked ((MonoString *) message, &error);
|
||||
if (!is_ok (&error)) {
|
||||
mono_error_cleanup (&error);
|
||||
msg = g_strdup ("(error while display System.Exception.Message property)");
|
||||
}
|
||||
} else {
|
||||
msg = g_strdup ("(System.Exception.Message property not available)");
|
||||
}
|
||||
}
|
||||
g_print ("[%p:] EXCEPTION handling: %s.%s: %s\n", (void*)mono_native_thread_id_get (), mono_object_class (obj)->name_space, mono_object_class (obj)->name, msg);
|
||||
g_free (msg);
|
||||
@@ -2831,8 +2839,14 @@ mono_invoke_unhandled_exception_hook (MonoObject *exc)
|
||||
MonoString *str = mono_object_to_string (exc, &other);
|
||||
char *msg = NULL;
|
||||
|
||||
if (str)
|
||||
msg = mono_string_to_utf8 (str);
|
||||
if (str) {
|
||||
MonoError inner_error;
|
||||
msg = mono_string_to_utf8_checked (str, &inner_error);
|
||||
if (!is_ok (&inner_error)) {
|
||||
msg = g_strdup_printf ("Nested exception while formatting original exception");
|
||||
mono_error_cleanup (&inner_error);
|
||||
}
|
||||
}
|
||||
else if (other) {
|
||||
char *original_backtrace = mono_exception_get_managed_backtrace ((MonoException*)exc);
|
||||
char *nested_backtrace = mono_exception_get_managed_backtrace ((MonoException*)other);
|
||||
|
||||
+18
-6
@@ -765,6 +765,19 @@ cvtMonoType(MonoTypeEnum t)
|
||||
/* */
|
||||
/*------------------------------------------------------------------*/
|
||||
|
||||
static void
|
||||
decodeParmString (MonoString *s)
|
||||
{
|
||||
char *str = mono_string_to_utf8(s, &error);
|
||||
if (is_ok (&error)) {
|
||||
printf("[STRING:%p:%s], ", s, str);
|
||||
g_free (str);
|
||||
} else {
|
||||
mono_error_cleanup (&error);
|
||||
printf("[STRING:%p:], ", s);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
decodeParm(MonoType *type, void *curParm, int size)
|
||||
{
|
||||
@@ -813,7 +826,7 @@ enum_parmtype:
|
||||
MonoString *s = *((MonoString **) curParm);
|
||||
if (s) {
|
||||
g_assert (((MonoObject *) s)->vtable->klass == mono_defaults.string_class);
|
||||
printf("[STRING:%p:%s], ", s, mono_string_to_utf8(s));
|
||||
decodeParmString (s);
|
||||
} else {
|
||||
printf("[STRING:null], ");
|
||||
}
|
||||
@@ -828,8 +841,7 @@ enum_parmtype:
|
||||
klass = obj->vtable->klass;
|
||||
printf("%p [%p] ",obj,curParm);
|
||||
if (klass == mono_defaults.string_class) {
|
||||
printf("[STRING:%p:%s]",
|
||||
obj, mono_string_to_utf8 ((MonoString *) obj));
|
||||
decodeParmString ((MonoString *)obj);
|
||||
} else if (klass == mono_defaults.int32_class) {
|
||||
printf("[INT32:%p:%d]",
|
||||
obj, *(gint32 *)((char *)obj + sizeof (MonoObject)));
|
||||
@@ -969,8 +981,8 @@ enter_method (MonoMethod *method, RegParm *rParm, char *sp)
|
||||
if (obj->vtable) {
|
||||
klass = obj->vtable->klass;
|
||||
if (klass == mono_defaults.string_class) {
|
||||
printf ("this:[STRING:%p:%s], ",
|
||||
obj, mono_string_to_utf8 ((MonoString *)obj));
|
||||
printf ("this:");
|
||||
decodeParmString((MonoString *)obj);
|
||||
} else {
|
||||
printf ("this:%p[%s.%s], ",
|
||||
obj, klass->name_space, klass->name);
|
||||
@@ -1126,7 +1138,7 @@ handle_enum:
|
||||
;
|
||||
if (s) {
|
||||
g_assert (((MonoObject *)s)->vtable->klass == mono_defaults.string_class);
|
||||
printf ("[STRING:%p:%s]", s, mono_string_to_utf8 (s));
|
||||
decodeParmString (s);
|
||||
} else
|
||||
printf ("[STRING:null], ");
|
||||
break;
|
||||
|
||||
@@ -203,7 +203,8 @@ static inline void print_report (const gchar *format, ...)
|
||||
prop = mono_class_get_property_from_name (klass, "StackTrace");
|
||||
str = (MonoString*)mono_property_get_value_checked (prop, NULL, NULL, &error);
|
||||
mono_error_assert_ok (&error);
|
||||
stack_trace = mono_string_to_utf8 (str);
|
||||
stack_trace = mono_string_to_utf8_checked (str, &error);
|
||||
mono_error_assert_ok (&error);
|
||||
|
||||
fprintf (stdout, "-= Stack Trace =-\n%s\n\n", stack_trace);
|
||||
g_free (stack_trace);
|
||||
@@ -223,6 +224,7 @@ static inline void append_report (GString **report, const gchar *format, ...)
|
||||
|
||||
static gboolean saved_strings_find_func (gpointer key, gpointer value, gpointer user_data)
|
||||
{
|
||||
MonoError error;
|
||||
SavedStringFindInfo *info = (SavedStringFindInfo*)user_data;
|
||||
SavedString *saved = (SavedString*)value;
|
||||
gchar *utf_str;
|
||||
@@ -231,7 +233,8 @@ static gboolean saved_strings_find_func (gpointer key, gpointer value, gpointer
|
||||
if (!info || !saved || mono_string_length (saved->string) != info->len)
|
||||
return FALSE;
|
||||
|
||||
utf_str = mono_string_to_utf8 (saved->string);
|
||||
utf_str = mono_string_to_utf8_checked (saved->string, &error);
|
||||
mono_error_assert_ok (&error);
|
||||
hash = do_calc_string_hash (0, utf_str);
|
||||
g_free (utf_str);
|
||||
|
||||
|
||||
@@ -992,9 +992,11 @@ check_reference_for_xdomain (GCObject **ptr, GCObject *obj, MonoDomain *domain)
|
||||
break;
|
||||
}
|
||||
|
||||
if (ref->vtable->klass == mono_defaults.string_class)
|
||||
str = mono_string_to_utf8 ((MonoString*)ref);
|
||||
else
|
||||
if (ref->vtable->klass == mono_defaults.string_class) {
|
||||
MonoError error;
|
||||
str = mono_string_to_utf8_checked ((MonoString*)ref, &error);
|
||||
mono_error_cleanup (&error);
|
||||
} else
|
||||
str = NULL;
|
||||
g_print ("xdomain reference in %p (%s.%s) at offset %d (%s) to %p (%s.%s) (%s) - pointed to by:\n",
|
||||
obj, obj->vtable->klass->name_space, obj->vtable->klass->name,
|
||||
|
||||
Reference in new issue
Block a user