mono/metadata/appdomain.c

   1 /*
   2  * appdomain.c: AppDomain functions
   3  *
   4  * Author:
   5  *      Dietmar Maurer (dietmar@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <string.h>
  13
  14 #if HAVE_BOEHM_GC
  15 #include <gc/gc.h>
  16 #endif
  17
  18 #include <mono/metadata/object.h>
  19 #include <mono/metadata/appdomain.h>
  20 #include <mono/metadata/assembly.h>
  21 #include <mono/metadata/exception.h>
  22 #include <mono/metadata/threads.h>
  23 #include <mono/metadata/socket-io.h>
  24
  25 HANDLE mono_delegate_semaphore = NULL;
  26 CRITICAL_SECTION mono_delegate_section;
  27 int mono_runtime_shutdown = 0;
  28
  29 /*
  30  * mono_runtime_init:
  31  * @domain: domain returned by mono_init ()
  32  *
  33  * Initialize the core AppDomain: this function will run also some
  34  * IL initialization code, so it needs the execution engine to be fully
  35  * operational.
  36  */
  37 void
  38 mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb)
  39 {
  40         MonoAppDomainSetup *setup;
  41         MonoAppDomain *ad;
  42         MonoClass *class;
  43
  44         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
  45         setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
  46         ves_icall_System_AppDomainSetup_InitAppDomainSetup (setup);
  47
  48         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
  49         ad = (MonoAppDomain *) mono_object_new (domain, class);
  50         ad->data = domain;
  51         domain->domain = ad;
  52         domain->setup = setup;
  53
  54         mono_delegate_semaphore = CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
  55         g_assert (mono_delegate_semaphore != INVALID_HANDLE_VALUE);
  56         InitializeCriticalSection (&mono_delegate_section);
  57
  58         mono_thread_init (domain, start_cb);
  59
  60         mono_network_init ();
  61
  62         return;
  63 }
  64
  65 void
  66 mono_runtime_cleanup (MonoDomain *domain)
  67 {
  68         mono_runtime_shutdown = 1;
  69
  70         /* signal all waiters in order to stop all workers (max. 0xffff) */
  71         ReleaseSemaphore (mono_delegate_semaphore, 0xffff, NULL);
  72
  73         mono_thread_cleanup ();
  74
  75         /* Do this after the thread cleanup, because subthreads might
  76          * still be doing socket calls.
  77          */
  78         mono_network_cleanup ();
  79 }
  80
  81 void
  82 ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
  83 {
  84         /* FIXME: implement me */
  85 }
  86
  87 /**
  88  * mono_domain_transfer_object:
  89  * @src: the source domain
  90  * @dst: the destination domain
  91  * @obj: the object to transfer
  92  *
  93  * This function is used to transfer objects between domains. This is done by
  94  * marshalling or serialisation.
  95  */
  96 static MonoObject *
  97 mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj)
  98 {
  99         MonoClass *klass;
 100         MonoObject *res;
 101
 102         if (!obj)
 103                 return NULL;
 104
 105         g_assert (obj->vtable->domain == src);
 106
 107         /* fixme: transfer an object from one domain into another */
 108
 109         klass = obj->vtable->klass;
 110
 111         if (MONO_CLASS_IS_ARRAY (klass)) {
 112                 MonoArray *ao = (MonoArray *)obj;
 113                 int esize, ecount, i;
 114                 guint32 *sizes;
 115
 116                 esize = mono_array_element_size (klass);
 117                 if (ao->bounds == NULL) {
 118                         ecount = mono_array_length (ao);
 119                         res = (MonoObject *)mono_array_new_full (dst, klass, &ecount, NULL);
 120                 }
 121                 else {
 122                         sizes = alloca (klass->rank * sizeof(guint32) * 2);
 123                         ecount = 1;
 124                         for (i = 0; i < klass->rank; ++i) {
 125                                 sizes [i] = ao->bounds [i].length;
 126                                 ecount *= ao->bounds [i].length;
 127                                 sizes [i + klass->rank] = ao->bounds [i].lower_bound;
 128                         }
 129                         res = (MonoObject *)mono_array_new_full (dst, klass, sizes, sizes + klass->rank);
 130                 }
 131                 if (klass->element_class->valuetype) {
 132                         memcpy (res, (char *)ao + sizeof(MonoArray), esize * ecount);
 133                 } else {
 134                         g_assert (esize == sizeof (gpointer));
 135                         for (i = 0; i < ecount; i++) {
 136                                 int offset = sizeof (MonoArray) + esize * i;
 137                                 gpointer *src_ea = (gpointer *)((char *)ao + offset);
 138                                 gpointer *dst_ea = (gpointer *)((char *)res + offset);
 139
 140                                 *dst_ea = mono_domain_transfer_object (src, dst, *src_ea);
 141                         }
 142                 }
 143         } else if (klass == mono_defaults.string_class) {
 144                 MonoString *str = (MonoString *)obj;
 145                 res = (MonoObject *)mono_string_new_utf16 (dst,
 146                         (const guint16 *)mono_string_chars (str), str->length);
 147         } else {
 148                 /* FIXME: we need generic marshalling code here */
 149                 g_assert_not_reached ();
 150         }
 151
 152         return res;
 153 }
 154
 155 MonoObject *
 156 ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
 157 {
 158         MonoDomain *add = ad->data;
 159         MonoDomain *cur = mono_domain_get ();
 160         MonoObject *o;
 161         char *str;
 162
 163         g_assert (ad != NULL);
 164         g_assert (name != NULL);
 165
 166         str = mono_string_to_utf8 (name);
 167
 168         mono_domain_lock (add);
 169         if (!strcmp (str, "APPBASE"))
 170                 o = (MonoObject *)add->setup->application_base;
 171         else if (!strcmp (str, "APP_CONFIG_FILE"))
 172                 o = (MonoObject *)add->setup->configuration_file;
 173         else if (!strcmp (str, "DYNAMIC_BASE"))
 174                 o = (MonoObject *)add->setup->dynamic_base;
 175         else if (!strcmp (str, "APP_NAME"))
 176                 o = (MonoObject *)add->setup->application_name;
 177         else if (!strcmp (str, "CACHE_BASE"))
 178                 o = (MonoObject *)add->setup->cache_path;
 179         else if (!strcmp (str, "PRIVATE_BINPATH"))
 180                 o = (MonoObject *)add->setup->private_bin_path;
 181         else if (!strcmp (str, "BINPATH_PROBE_ONLY"))
 182                 o = (MonoObject *)add->setup->private_bin_path_probe;
 183         else if (!strcmp (str, "SHADOW_COPY_DIRS"))
 184                 o = (MonoObject *)add->setup->shadow_copy_directories;
 185         else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
 186                 o = (MonoObject *)add->setup->shadow_copy_files;
 187         else
 188                 o = g_hash_table_lookup (add->env, str);
 189
 190         mono_domain_unlock (add);
 191         g_free (str);
 192
 193         if (!o)
 194                 return NULL;
 195
 196         return mono_domain_transfer_object (add, cur, o);
 197 }
 198
 199 void
 200 ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
 201 {
 202         MonoDomain *add = ad->data;
 203         MonoDomain *cur = mono_domain_get ();
 204         MonoObject *o;
 205         char *str;
 206
 207         g_assert (ad != NULL);
 208         g_assert (name != NULL);
 209
 210         o = mono_domain_transfer_object (cur, add, data);
 211
 212         /* fixme: need a hash func for MonoString */
 213         str = mono_string_to_utf8 (name);
 214         mono_domain_lock (add);
 215         g_hash_table_insert (add->env, str, o);
 216         mono_domain_unlock (add);
 217         g_free (str);
 218 }
 219
 220 MonoAppDomainSetup *
 221 ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
 222 {
 223         g_assert (ad != NULL);
 224         g_assert (ad->data != NULL);
 225
 226         return ad->data->setup;
 227 }
 228
 229 MonoString *
 230 ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
 231 {
 232         g_assert (ad != NULL);
 233         g_assert (ad->data != NULL);
 234
 235         return mono_string_new (ad->data, ad->data->friendly_name);
 236 }
 237
 238 MonoAppDomain *
 239 ves_icall_System_AppDomain_getCurDomain ()
 240 {
 241         MonoDomain *add = mono_domain_get ();
 242         return add->domain;
 243 }
 244
 245 MonoAppDomain *
 246 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 247 {
 248         MonoDomain *domain = mono_domain_get ();
 249         MonoClass *adclass;
 250         MonoAppDomain *ad;
 251         MonoDomain *data;
 252
 253         adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 254
 255         /* FIXME: pin all those objects */
 256         ad = (MonoAppDomain *) mono_object_new (domain, adclass);
 257         ad->data = data = mono_domain_create ();
 258         data->domain = ad;
 259         data->setup = setup;
 260         data->friendly_name = mono_string_to_utf8 (friendly_name);
 261
 262         /* FIXME: what to do next ? */
 263
 264         return ad;
 265 }
 266
 267 typedef struct {
 268         MonoArray *res;
 269         MonoDomain *domain;
 270         int idx;
 271 } add_assembly_helper_t;
 272
 273 static void
 274 add_assembly (gpointer key, gpointer value, gpointer user_data)
 275 {
 276         add_assembly_helper_t *ah = (add_assembly_helper_t *) user_data;
 277
 278         mono_array_set (ah->res, gpointer, ah->idx++, mono_assembly_get_object (ah->domain, value));
 279 }
 280
 281 MonoArray *
 282 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
 283 {
 284         MonoDomain *domain = ad->data;
 285         static MonoClass *System_Reflection_Assembly;
 286         MonoArray *res;
 287         add_assembly_helper_t ah;
 288
 289         if (!System_Reflection_Assembly)
 290                 System_Reflection_Assembly = mono_class_from_name (
 291                         mono_defaults.corlib, "System.Reflection", "Assembly");
 292
 293         res = mono_array_new (domain, System_Reflection_Assembly, g_hash_table_size (domain->assemblies));
 294
 295         ah.domain = domain;
 296         ah.res = res;
 297         ah.idx = 0;
 298         mono_domain_lock (domain);
 299         g_hash_table_foreach (domain->assemblies, add_assembly, &ah);
 300         mono_domain_unlock (domain);
 301
 302         return res;
 303 }
 304
 305 MonoReflectionAssembly *
 306 ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
 307 {
 308         MonoDomain *domain = mono_domain_get ();
 309         char *name, *filename;
 310         MonoImageOpenStatus status = MONO_IMAGE_OK;
 311         MonoAssembly *ass;
 312
 313         name = filename = mono_string_to_utf8 (fname);
 314
 315         /* FIXME: move uri handling to mono_assembly_open */
 316         if (strncmp (filename, "file://", 7) == 0)
 317                 filename += 7;
 318
 319         ass = mono_assembly_open (filename, &status);
 320
 321         g_free (name);
 322
 323         if (!ass){
 324                 MonoException *exc = mono_get_exception_file_not_found (fname);
 325                 mono_raise_exception (exc);
 326         }
 327
 328         return mono_assembly_get_object (domain, ass);
 329 }
 330
 331
 332 MonoReflectionAssembly *
 333 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoReflectionAssemblyName *assRef, MonoObject *evidence)
 334 {
 335         MonoDomain *domain = ad->data;
 336         char *name;
 337         MonoImageOpenStatus status = MONO_IMAGE_OK;
 338         MonoAssembly *ass;
 339         MonoAssemblyName aname;
 340
 341         memset (&aname, 0, sizeof (aname));
 342
 343         /* FIXME : examine evidence? */
 344
 345         g_assert (assRef != NULL);
 346         g_assert (assRef->name != NULL);
 347
 348         /* FIXME : examine version, culture info */
 349
 350         aname.name = name = mono_string_to_utf8 (assRef->name);
 351
 352         ass = mono_assembly_load (&aname, NULL, &status);
 353
 354         g_free (name);
 355
 356         if (!ass) {
 357                 /* FIXME: it doesn't make much sense since we really don't have a filename ... */
 358                 MonoException *exc = mono_get_exception_file_not_found (assRef->name);
 359                 mono_raise_exception (exc);
 360         }
 361
 362         return mono_assembly_get_object (domain, ass);
 363 }
 364
 365 void
 366 ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
 367 {
 368         mono_domain_unload (ad->data, FALSE);
 369 }
 370
 371 gint32
 372 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
 373                                             MonoObject *evidence, MonoArray *args)
 374 {
 375         MonoDomain *cdom = mono_domain_get ();
 376         MonoAssembly *assembly;
 377         MonoImage *image;
 378         MonoMethod *method;
 379         MonoObject *margs;
 380         char *filename;
 381         gint32 res;
 382
 383         mono_domain_set (ad->data);
 384
 385         filename = mono_string_to_utf8 (file);
 386         assembly = mono_assembly_open (filename, NULL);
 387         g_free (filename);
 388
 389         if (!assembly) {
 390                 mono_raise_exception ((MonoException *)mono_exception_from_name (
 391                         mono_defaults.corlib, "System.IO", "FileNotFoundException"));
 392         }
 393
 394         image = assembly->image;
 395         method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
 396
 397         if (!method)
 398                 g_error ("No entry point method found in %s", image->name);
 399
 400         margs = mono_domain_transfer_object (cdom, ad->data, (MonoObject *)args);
 401         res = mono_runtime_exec_main (method, (MonoArray *)margs, NULL);
 402
 403         mono_domain_set (cdom);
 404
 405         return res;
 406 }
 407