static MonoBoolean
construct_culture (MonoCultureInfo *this_obj, const CultureInfoEntry *ci, MonoError *error)
{
MonoDomain *domain = mono_domain_get ();
error_init (error);
this_obj->lcid = ci->lcid;
MONO_OBJECT_SETREF (this_obj, name, mono_string_new (domain, idx2string (ci->name)));
MONO_OBJECT_SETREF (this_obj, englishname, mono_string_new (domain, idx2string (ci->englishname)));
MONO_OBJECT_SETREF (this_obj, nativename, mono_string_new (domain, idx2string (ci->nativename)));
MONO_OBJECT_SETREF (this_obj, win3lang, mono_string_new (domain, idx2string (ci->win3lang)));
MONO_OBJECT_SETREF (this_obj, iso3lang, mono_string_new (domain, idx2string (ci->iso3lang)));
MONO_OBJECT_SETREF (this_obj, iso2lang, mono_string_new (domain, idx2string (ci->iso2lang)));
// It's null for neutral cultures
if (ci->territory > 0)
MONO_OBJECT_SETREF (this_obj, territory, mono_string_new (domain, idx2string (ci->territory)));
MonoArray *native_calendar_names = create_names_array_idx (ci->native_calendar_names, NUM_CALENDARS, error);
return_val_if_nok (error, FALSE);
MONO_OBJECT_SETREF (this_obj, native_calendar_names, native_calendar_names);
this_obj->parent_lcid = ci->parent_lcid;
this_obj->datetime_index = ci->datetime_format_index;
this_obj->number_index = ci->number_format_index;
this_obj->calendar_type = ci->calendar_type;
this_obj->text_info_data = &ci->text_info;
return TRUE;
}
gpointer
ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned, MonoStringHandle name, MonoBoolean *created, MonoError *error)
{
gpointer mutex;
*created = TRUE;
/* Need to blow away any old errors here, because code tests
* for ERROR_ALREADY_EXISTS on success (!) to see if a mutex
* was freshly created */
mono_w32error_set_last (ERROR_SUCCESS);
if (MONO_HANDLE_IS_NULL (name)) {
mutex = mutex_create (owned);
} else {
gchar *utf8_name = mono_string_handle_to_utf8 (name, error);
return_val_if_nok (error, NULL);
mutex = namedmutex_create (owned, utf8_name);
if (mono_w32error_get_last () == ERROR_ALREADY_EXISTS)
*created = FALSE;
g_free (utf8_name);
}
return mutex;
}
MonoException *
mono_get_exception_runtime_wrapped_checked (MonoObject *wrapped_exception, MonoError *error)
{
MonoClass *klass;
MonoObject *o;
MonoMethod *method;
MonoDomain *domain = mono_domain_get ();
gpointer params [16];
klass = mono_class_load_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", "RuntimeWrappedException");
o = mono_object_new_checked (domain, klass, error);
mono_error_assert_ok (error);
g_assert (o != NULL);
method = mono_class_get_method_from_name (klass, ".ctor", 1);
g_assert (method);
params [0] = wrapped_exception;
mono_runtime_invoke_checked (method, o, params, error);
return_val_if_nok (error, NULL);
return (MonoException *)o;
}
static MonoArray*
create_names_array_idx_dynamic (const guint16 *names, int ml, MonoError *error)
{
MonoArray *ret;
MonoDomain *domain;
int i, len = 0;
error_init (error);
if (names == NULL)
return NULL;
domain = mono_domain_get ();
for (i = 0; i < ml; i++) {
if (names [i] == 0)
break;
len++;
}
ret = mono_array_new_cached (mono_domain_get (), mono_get_string_class (), len, error);
return_val_if_nok (error, NULL);
for(i = 0; i < len; i++)
mono_array_setref (ret, i, mono_string_new (domain, pattern2string (names [i])));
return ret;
}
gpointer
ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoStringHandle name, gint32 rights G_GNUC_UNUSED, gint32 *err, MonoError *error)
{
gchar *utf8_name = mono_string_handle_to_utf8 (name, error);
return_val_if_nok (error, NULL);
gpointer handle = mono_w32mutex_open (utf8_name, rights, err);
g_free (utf8_name);
return handle;
}
guint32
mono_dynstream_insert_mstring (MonoDynamicStream *sh, MonoString *str, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
mono_error_init (error);
char *name = mono_string_to_utf8_checked (str, error);
return_val_if_nok (error, -1);
guint32 idx;
idx = mono_dynstream_insert_string (sh, name);
g_free (name);
return idx;
}
gpointer
ves_icall_System_Security_Principal_WindowsIdentity_GetUserToken (MonoStringHandle username, MonoError *error)
{
gpointer token = (gpointer)-2;
error_init (error);
#if defined (HAVE_PWD_H) && !defined (HOST_WASM)
#ifdef HAVE_GETPWNAM_R
struct passwd pwd;
size_t fbufsize;
gchar *fbuf;
gint32 retval;
#endif
struct passwd *p;
gchar *utf8_name;
gboolean result;
utf8_name = mono_string_handle_to_utf8 (username, error);
return_val_if_nok (error, NULL);
#ifdef HAVE_GETPWNAM_R
#ifdef _SC_GETPW_R_SIZE_MAX
fbufsize = mono_sysconf (_SC_GETPW_R_SIZE_MAX);
#else
fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
#endif
fbuf = (gchar *)g_malloc0 (fbufsize);
retval = getpwnam_r (utf8_name, &pwd, fbuf, fbufsize, &p);
result = ((retval == 0) && (p == &pwd));
#else
/* default to non thread-safe but posix compliant function */
p = getpwnam (utf8_name);
result = (p != NULL);
#endif
if (result) {
token = GINT_TO_POINTER (p->pw_uid);
}
#ifdef HAVE_GETPWNAM_R
g_free (fbuf);
#endif
g_free (utf8_name);
#endif /* HAVE_PWD_H */
return token;
}
static MonoException *
create_exception_two_strings (MonoClass *klass, MonoString *a1, MonoString *a2, MonoError *error)
{
MonoDomain *domain = mono_domain_get ();
MonoMethod *method = NULL;
MonoObject *o;
int count = 1;
gpointer args [2];
gpointer iter;
MonoMethod *m;
if (a2 != NULL)
count++;
o = mono_object_new_checked (domain, klass, error);
mono_error_assert_ok (error);
iter = NULL;
while ((m = mono_class_get_methods (klass, &iter))) {
MonoMethodSignature *sig;
if (strcmp (".ctor", mono_method_get_name (m)))
continue;
sig = mono_method_signature (m);
if (sig->param_count != count)
continue;
if (sig->params [0]->type != MONO_TYPE_STRING)
continue;
if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING)
continue;
method = m;
break;
}
args [0] = a1;
args [1] = a2;
mono_runtime_invoke_checked (method, o, args, error);
return_val_if_nok (error, NULL);
return (MonoException *) o;
}
static MonoArray*
create_names_array_idx (const guint16 *names, int ml, MonoError *error)
{
MonoArray *ret;
MonoDomain *domain;
int i;
error_init (error);
if (names == NULL)
return NULL;
domain = mono_domain_get ();
ret = mono_array_new_cached (mono_domain_get (), mono_get_string_class (), ml, error);
return_val_if_nok (error, NULL);
for(i = 0; i < ml; i++)
mono_array_setref (ret, i, mono_string_new (domain, dtidx2string (names [i])));
return ret;
}
static MonoArray*
create_group_sizes_array (const gint *gs, gint ml, MonoError *error)
{
MonoArray *ret;
int i, len = 0;
error_init (error);
for (i = 0; i < ml; i++) {
if (gs [i] == -1)
break;
len++;
}
ret = mono_array_new_cached (mono_domain_get (),
mono_get_int32_class (), len, error);
return_val_if_nok (error, NULL);
for(i = 0; i < len; i++)
mono_array_set (ret, gint32, i, gs [i]);
return ret;
}
MonoException *
mono_get_exception_reflection_type_load_checked (MonoArray *types, MonoArray *exceptions, MonoError *error)
{
MonoClass *klass;
gpointer args [2];
MonoObject *exc;
MonoMethod *method;
gpointer iter;
klass = mono_class_load_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException");
mono_class_init (klass);
/* Find the Type[], Exception[] ctor */
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
if (!strcmp (".ctor", mono_method_get_name (method))) {
MonoMethodSignature *sig = mono_method_signature (method);
if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_SZARRAY && sig->params [1]->type == MONO_TYPE_SZARRAY)
break;
}
method = NULL;
}
g_assert (method);
args [0] = types;
args [1] = exceptions;
exc = mono_object_new_checked (mono_domain_get (), klass, error);
mono_error_assert_ok (error);
mono_runtime_invoke_checked (method, exc, args, error);
return_val_if_nok (error, NULL);
return (MonoException *) exc;
}
MonoException *
mono_get_exception_type_initialization_checked (const gchar *type_name, MonoException *inner, MonoError *error)
{
MonoClass *klass;
gpointer args [2];
MonoObject *exc;
MonoMethod *method;
gpointer iter;
klass = mono_class_load_from_name (mono_get_corlib (), "System", "TypeInitializationException");
mono_class_init (klass);
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
if (!strcmp (".ctor", mono_method_get_name (method))) {
MonoMethodSignature *sig = mono_method_signature (method);
if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_STRING && mono_class_from_mono_type (sig->params [1]) == mono_defaults.exception_class)
break;
}
method = NULL;
}
g_assert (method);
args [0] = mono_string_new (mono_domain_get (), type_name);
args [1] = inner;
exc = mono_object_new_checked (mono_domain_get (), klass, error);
mono_error_assert_ok (error);
mono_runtime_invoke_checked (method, exc, args, error);
return_val_if_nok (error, NULL);
return (MonoException *) exc;
}
