[runtime] Mark mono_string_to_utf8 external only.

Runtime should use mono_string_to_utf8_checked.
This commit is contained in:
Aleksey Kliger committed 2016-05-26 15:13:37 -04:00
1 parent 5cb30c7c72
commit b884d173c7
24 files changed
+413 -168

No files matched your search

+13 -4
View File
@@ -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);
+4 -1
View File
@@ -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)
+11 -3
View File
@@ -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);
}
+3 -1
View File
@@ -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
View File
@@ -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)
+39 -27
View File
@@ -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);
}
+4 -1
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
}
+15 -6
View File
@@ -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)
+5 -1
View File
@@ -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);
+4 -2
View File
@@ -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;
}
+1
View File
@@ -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);
+6 -1
View File
@@ -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
View File
@@ -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))
+8 -3
View File
@@ -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;
+2 -1
View File
@@ -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);
+19 -6
View File
@@ -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);
}
+2 -1
View File
@@ -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;
}
+17 -3
View File
@@ -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
View File
@@ -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;
+5 -2
View File
@@ -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);
+5 -3
View File
@@ -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,