mono/metadata/appdomain.c

   1 /*
   2  * appdomain.c: AppDomain functions
   3  *
   4  * Authors:
   5  *      Dietmar Maurer (dietmar@ximian.com)
   6  *      Patrik Torstensson
   7  *      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   8  *
   9  * (c) 2001-2003 Ximian, Inc. (http://www.ximian.com)
  10  */
  11
  12 #include <config.h>
  13 #include <glib.h>
  14 #include <string.h>
  15
  16 #include <mono/os/gc_wrapper.h>
  17
  18 #include <mono/metadata/object.h>
  19 #include <mono/metadata/domain-internals.h>
  20 #include "mono/metadata/metadata-internals.h"
  21 #include <mono/metadata/assembly.h>
  22 #include <mono/metadata/exception.h>
  23 #include <mono/metadata/threads.h>
  24 #include <mono/metadata/socket-io.h>
  25 #include <mono/metadata/tabledefs.h>
  26 #include <mono/metadata/gc-internal.h>
  27 #include <mono/metadata/marshal.h>
  28 #include <mono/utils/mono-uri.h>
  29
  30 #define MONO_CORLIB_VERSION 24
  31
  32 CRITICAL_SECTION mono_delegate_section;
  33
  34 static gunichar2 process_guid [36];
  35 static gboolean process_guid_set = FALSE;
  36
  37 static gboolean shutting_down = FALSE;
  38
  39 static MonoAssembly *
  40 mono_domain_assembly_preload (MonoAssemblyName *aname,
  41                               gchar **assemblies_path,
  42                               gpointer user_data);
  43
  44 static void
  45 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
  46
  47 static MonoMethod *
  48 look_for_method_by_name (MonoClass *klass, const gchar *name);
  49
  50 static void
  51 mono_domain_unload (MonoDomain *domain);
  52
  53 /*
  54  * mono_runtime_init:
  55  * @domain: domain returned by mono_init ()
  56  *
  57  * Initialize the core AppDomain: this function will run also some
  58  * IL initialization code, so it needs the execution engine to be fully
  59  * operational.
  60  *
  61  * AppDomain.SetupInformation is set up in mono_runtime_exec_main, where
  62  * we know the entry_assembly.
  63  *
  64  */
  65 void
  66 mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
  67                    MonoThreadAttachCB attach_cb)
  68 {
  69         MonoAppDomainSetup *setup;
  70         MonoAppDomain *ad;
  71         MonoClass *class;
  72         MonoString *arg;
  73
  74         MONO_GC_PRE_INIT ();
  75         mono_marshal_init ();
  76
  77         mono_install_assembly_preload_hook (mono_domain_assembly_preload, NULL);
  78         mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
  79         mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
  80
  81         mono_thread_init (start_cb, attach_cb);
  82
  83         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
  84         setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
  85
  86         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
  87         ad = (MonoAppDomain *) mono_object_new (domain, class);
  88         ad->data = domain;
  89         domain->domain = ad;
  90         domain->setup = setup;
  91
  92         InitializeCriticalSection (&mono_delegate_section);
  93
  94         mono_context_init (domain);
  95         mono_context_set (domain->default_context);
  96
  97         mono_type_initialization_init ();
  98
  99
 100         /*
 101          * Create an instance early since we can't do it when there is no memory.
 102          */
 103         arg = mono_string_new (domain, "Out of memory");
 104         domain->out_of_memory_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "OutOfMemoryException", arg, NULL);
 105
 106         /*
 107          * These two are needed because the signal handlers might be executing on
 108          * an alternate stack, and Boehm GC can't handle that.
 109          */
 110         arg = mono_string_new (domain, "A null value was found where an object instance was required");
 111         domain->null_reference_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "NullReferenceException", arg, NULL);
 112         arg = mono_string_new (domain, "The requested operation caused a stack overflow.");
 113         domain->stack_overflow_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL);
 114
 115         /* GC init has to happen after thread init */
 116         mono_gc_init ();
 117
 118         mono_network_init ();
 119
 120         return;
 121 }
 122
 123 static int
 124 mono_get_corlib_version (void)
 125 {
 126         MonoClass *klass;
 127         MonoClassField *field;
 128         MonoObject *value;
 129
 130         klass = mono_class_from_name (mono_defaults.corlib, "System", "Environment");
 131         mono_class_init (klass);
 132         field = mono_class_get_field_from_name (klass, "mono_corlib_version");
 133         if (!field)
 134                 return -1;
 135         if (! (field->type->attrs & FIELD_ATTRIBUTE_STATIC))
 136                 return -1;
 137         value = mono_field_get_value_object (mono_domain_get (), field, NULL);
 138         return *(gint32*)((gchar*)value + sizeof (MonoObject));
 139 }
 140
 141 const char*
 142 mono_check_corlib_version (void)
 143 {
 144         int version = mono_get_corlib_version ();
 145         if (version != MONO_CORLIB_VERSION)
 146                 return g_strdup_printf ("expected corlib version %d, found %d.", MONO_CORLIB_VERSION, version);
 147         else
 148                 return NULL;
 149 }
 150
 151 void
 152 mono_context_init (MonoDomain *domain)
 153 {
 154         MonoClass *class;
 155         MonoAppContext *context;
 156
 157         class = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
 158         context = (MonoAppContext *) mono_object_new (domain, class);
 159         context->domain_id = domain->domain_id;
 160         context->context_id = 0;
 161         domain->default_context = context;
 162 }
 163
 164 /* This must not be called while there are still running threads executing
 165  * managed code.
 166  */
 167 void
 168 mono_runtime_cleanup (MonoDomain *domain)
 169 {
 170         shutting_down = TRUE;
 171
 172         /* This ends up calling any pending pending (for at most 2 seconds) */
 173         mono_gc_cleanup ();
 174
 175         mono_network_cleanup ();
 176 }
 177
 178 static MonoDomainFunc quit_function = NULL;
 179
 180 void
 181 mono_runtime_install_cleanup (MonoDomainFunc func)
 182 {
 183         quit_function = func;
 184 }
 185
 186 void
 187 mono_runtime_quit ()
 188 {
 189         if (quit_function != NULL)
 190                 quit_function (mono_get_root_domain (), NULL);
 191 }
 192
 193 gboolean
 194 mono_runtime_is_shutting_down (void)
 195 {
 196         return shutting_down;
 197 }
 198
 199 gboolean
 200 mono_domain_has_type_resolve (MonoDomain *domain)
 201 {
 202         static MonoClassField *field = NULL;
 203         MonoObject *o;
 204
 205         if (field == NULL) {
 206                 MonoClass *klass = mono_defaults.appdomain_class;
 207                 int i;
 208
 209                 for (i = 0; i < klass->field.count; ++i)
 210                         if (strcmp (klass->fields [i].name, "TypeResolve") == 0)
 211                                 field = &klass->fields [i];
 212                 g_assert (field);
 213         }
 214
 215         mono_field_get_value ((MonoObject*)(domain->domain), field, &o);
 216         return o != NULL;
 217 }
 218
 219 MonoReflectionAssembly *
 220 mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb)
 221 {
 222         MonoClass *klass;
 223         void *params [1];
 224         static MonoMethod *method = NULL;
 225
 226         g_assert (domain != NULL && ((name != NULL) || (tb != NULL)));
 227
 228         if (method == NULL) {
 229                 klass = domain->domain->mbr.obj.vtable->klass;
 230                 g_assert (klass);
 231
 232                 method = look_for_method_by_name (klass, "DoTypeResolve");
 233                 if (method == NULL) {
 234                         g_warning ("Method AppDomain.DoTypeResolve not found.\n");
 235                         return NULL;
 236                 }
 237         }
 238
 239         if (name)
 240                 *params = (MonoObject*)mono_string_new (mono_domain_get (), name);
 241         else
 242                 *params = tb;
 243         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 244 }
 245
 246 /*
 247  * mono_domain_set:
 248  *
 249  *   Set the current appdomain to @domain. If @force is set, set it even
 250  * if it is being unloaded.
 251  * Returns:
 252  *   - TRUE on success
 253  *   - FALSE if the domain is being unloaded
 254  */
 255 gboolean
 256 mono_domain_set (MonoDomain *domain, gboolean force)
 257 {
 258         if (!force && (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED))
 259                 return FALSE;
 260
 261         mono_domain_set_internal (domain);
 262
 263         return TRUE;
 264 }
 265
 266 MonoObject *
 267 ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
 268 {
 269         MonoDomain *add = ad->data;
 270         MonoObject *o;
 271         char *str;
 272
 273         MONO_ARCH_SAVE_REGS;
 274
 275         g_assert (ad != NULL);
 276         g_assert (name != NULL);
 277
 278         str = mono_string_to_utf8 (name);
 279
 280         mono_domain_lock (add);
 281
 282         if (!strcmp (str, "APPBASE"))
 283                 o = (MonoObject *)add->setup->application_base;
 284         else if (!strcmp (str, "APP_CONFIG_FILE"))
 285                 o = (MonoObject *)add->setup->configuration_file;
 286         else if (!strcmp (str, "DYNAMIC_BASE"))
 287                 o = (MonoObject *)add->setup->dynamic_base;
 288         else if (!strcmp (str, "APP_NAME"))
 289                 o = (MonoObject *)add->setup->application_name;
 290         else if (!strcmp (str, "CACHE_BASE"))
 291                 o = (MonoObject *)add->setup->cache_path;
 292         else if (!strcmp (str, "PRIVATE_BINPATH"))
 293                 o = (MonoObject *)add->setup->private_bin_path;
 294         else if (!strcmp (str, "BINPATH_PROBE_ONLY"))
 295                 o = (MonoObject *)add->setup->private_bin_path_probe;
 296         else if (!strcmp (str, "SHADOW_COPY_DIRS"))
 297                 o = (MonoObject *)add->setup->shadow_copy_directories;
 298         else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
 299                 o = (MonoObject *)add->setup->shadow_copy_files;
 300         else
 301                 o = mono_g_hash_table_lookup (add->env, name);
 302
 303         mono_domain_unlock (add);
 304         g_free (str);
 305
 306         if (!o)
 307                 return NULL;
 308
 309         return o;
 310 }
 311
 312 void
 313 ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
 314 {
 315         MonoDomain *add = ad->data;
 316
 317         MONO_ARCH_SAVE_REGS;
 318
 319         g_assert (ad != NULL);
 320         g_assert (name != NULL);
 321
 322         mono_domain_lock (add);
 323
 324         mono_g_hash_table_insert (add->env, name, data);
 325
 326         mono_domain_unlock (add);
 327 }
 328
 329 MonoAppDomainSetup *
 330 ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
 331 {
 332         MONO_ARCH_SAVE_REGS;
 333
 334         g_assert (ad != NULL);
 335         g_assert (ad->data != NULL);
 336
 337         return ad->data->setup;
 338 }
 339
 340 MonoString *
 341 ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
 342 {
 343         MONO_ARCH_SAVE_REGS;
 344
 345         g_assert (ad != NULL);
 346         g_assert (ad->data != NULL);
 347
 348         return mono_string_new (ad->data, ad->data->friendly_name);
 349 }
 350
 351 MonoAppDomain *
 352 ves_icall_System_AppDomain_getCurDomain ()
 353 {
 354         MonoDomain *add = mono_domain_get ();
 355
 356         MONO_ARCH_SAVE_REGS;
 357
 358         return add->domain;
 359 }
 360
 361 MonoAppDomain *
 362 ves_icall_System_AppDomain_getDomainByID (gint32 domain_id)
 363 {
 364         MonoDomain *add = mono_domain_get_by_id (domain_id);
 365
 366         MONO_ARCH_SAVE_REGS;
 367
 368         return ((add == NULL) ? NULL : add->domain);
 369 }
 370
 371 MonoAppDomain *
 372 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 373 {
 374         /*MonoDomain *domain = mono_domain_get (); */
 375         MonoClass *adclass;
 376         MonoAppDomain *ad;
 377         MonoDomain *data;
 378
 379         MONO_ARCH_SAVE_REGS;
 380
 381         adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 382
 383         /* FIXME: pin all those objects */
 384         data = mono_domain_create();
 385
 386         ad = (MonoAppDomain *) mono_object_new (data, adclass);
 387         ad->data = data;
 388         data->domain = ad;
 389         data->setup = setup;
 390         data->friendly_name = mono_string_to_utf8 (friendly_name);
 391         data->out_of_memory_ex = mono_exception_from_name_domain (data, mono_defaults.corlib, "System", "OutOfMemoryException");
 392
 393         mono_context_init (data);
 394
 395         /* FIXME: what to do next ? */
 396
 397         return ad;
 398 }
 399
 400 typedef struct {
 401         MonoArray *res;
 402         MonoDomain *domain;
 403         int idx;
 404 } add_assembly_helper_t;
 405
 406 static void
 407 add_assembly (gpointer key, gpointer value, gpointer user_data)
 408 {
 409         add_assembly_helper_t *ah = (add_assembly_helper_t *) user_data;
 410
 411         mono_array_set (ah->res, gpointer, ah->idx++, mono_assembly_get_object (ah->domain, value));
 412 }
 413
 414 MonoArray *
 415 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
 416 {
 417         MonoDomain *domain = ad->data;
 418         static MonoClass *System_Reflection_Assembly;
 419         MonoArray *res;
 420         add_assembly_helper_t ah;
 421
 422         MONO_ARCH_SAVE_REGS;
 423
 424         if (!System_Reflection_Assembly)
 425                 System_Reflection_Assembly = mono_class_from_name (
 426                         mono_defaults.corlib, "System.Reflection", "Assembly");
 427
 428         res = mono_array_new (domain, System_Reflection_Assembly, g_hash_table_size (domain->assemblies));
 429
 430         ah.domain = domain;
 431         ah.res = res;
 432         ah.idx = 0;
 433         mono_domain_lock (domain);
 434         g_hash_table_foreach (domain->assemblies, add_assembly, &ah);
 435         mono_domain_unlock (domain);
 436
 437         return res;
 438 }
 439
 440 /*
 441  * Used to find methods in AppDomain class.
 442  * It only works if there are no multiple signatures for any given method name
 443  */
 444 static MonoMethod *
 445 look_for_method_by_name (MonoClass *klass, const gchar *name)
 446 {
 447         gint i;
 448         MonoMethod *method;
 449
 450         for (i = 0; i < klass->method.count; i++) {
 451                 method = klass->methods [i];
 452                 if (!strcmp (method->name, name))
 453                         return method;
 454         }
 455
 456         return NULL;
 457 }
 458
 459 static MonoReflectionAssembly *
 460 try_assembly_resolve (MonoDomain *domain, MonoString *fname)
 461 {
 462         MonoClass *klass;
 463         MonoMethod *method;
 464         void *params [1];
 465
 466         g_assert (domain != NULL && fname != NULL);
 467
 468         klass = domain->domain->mbr.obj.vtable->klass;
 469         g_assert (klass);
 470
 471         method = look_for_method_by_name (klass, "DoAssemblyResolve");
 472         if (method == NULL) {
 473                 g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
 474                 return NULL;
 475         }
 476
 477         *params = fname;
 478         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 479 }
 480
 481 static void
 482 add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass)
 483 {
 484         gint i;
 485
 486         if (!ass->aname.name)
 487                 return;
 488
 489         mono_domain_lock (domain);
 490
 491         if (g_hash_table_lookup (domain->assemblies, ass->aname.name)) {
 492                 mono_domain_unlock (domain);
 493                 return; /* This is ok while no lazy loading of assemblies */
 494         }
 495
 496         g_hash_table_insert (domain->assemblies, (gpointer) ass->aname.name, ass);
 497         mono_domain_unlock (domain);
 498
 499         if (ass->image->references)
 500                 for (i = 0; ass->image->references [i] != NULL; i++)
 501                         add_assemblies_to_domain (domain, ass->image->references [i]);
 502 }
 503
 504 static void
 505 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
 506 {
 507         MonoDomain *domain = mono_domain_get ();
 508         MonoReflectionAssembly *ref_assembly;
 509         MonoClass *klass;
 510         MonoMethod *method;
 511         void *params [1];
 512
 513         klass = domain->domain->mbr.obj.vtable->klass;
 514
 515
 516         method = look_for_method_by_name (klass, "DoAssemblyLoad");
 517         if (method == NULL) {
 518                 g_warning ("Method AppDomain.DoAssemblyLoad not found.\n");
 519                 return;
 520         }
 521
 522         add_assemblies_to_domain (domain, assembly);
 523
 524         ref_assembly = mono_assembly_get_object (domain, assembly);
 525         g_assert (ref_assembly);
 526
 527         *params = ref_assembly;
 528         mono_runtime_invoke (method, domain->domain, params, NULL);
 529 }
 530
 531 static gchar *
 532 reduce_path (const gchar *dirname)
 533 {
 534         gchar **parts;
 535         gchar *part;
 536         GList *list, *tmp;
 537         GString *result;
 538         gchar *res;
 539         gint i;
 540
 541         parts = g_strsplit (dirname, G_DIR_SEPARATOR_S, 0);
 542         list = NULL;
 543         for (i = 0; (part = parts [i]) != NULL; i++) {
 544                 if (!strcmp (part, "."))
 545                         continue;
 546
 547                 if (!strcmp (part, "..")) {
 548                         if (list && list->next) /* Don't remove root */
 549                                 list = g_list_delete_link (list, list);
 550                 } else {
 551                         list = g_list_prepend (list, part);
 552                 }
 553         }
 554
 555         result = g_string_new ("");
 556         list = g_list_reverse (list);
 557
 558         for (tmp = list; tmp; tmp = tmp->next) {
 559                 gchar *data = (gchar *) tmp->data;
 560
 561                 if (data && *data) {
 562 #ifdef PLATFORM_WIN32
 563                         if (result->len == 0)
 564                                 g_string_append_printf (result, "%s\\", data);
 565                         else if (result->str [result->len - 1] == '\\')
 566                                 g_string_append_printf (result, "%s", data);
 567                         else
 568 #endif
 569                                 g_string_append_printf (result, "%c%s",
 570                                                         G_DIR_SEPARATOR, data);
 571                 }
 572         }
 573
 574         res = result->str;
 575         g_string_free (result, FALSE);
 576         g_list_free (list);
 577         g_strfreev (parts);
 578         return res;
 579 }
 580
 581 static void
 582 set_domain_search_path (MonoDomain *domain)
 583 {
 584         MonoAppDomainSetup *setup;
 585         gchar **tmp;
 586         gchar *utf8;
 587         gint i;
 588         gint npaths = 0;
 589         gchar **pvt_split = NULL;
 590         GError *error = NULL;
 591         gint appbaselen = -1;
 592
 593         if ((domain->search_path != NULL) && !domain->setup->path_changed)
 594                 return;
 595
 596         setup = domain->setup;
 597         if (!setup->application_base)
 598                 return; /* Must set application base to get private path working */
 599
 600         npaths++;
 601         if (setup->private_bin_path) {
 602                 utf8 = mono_string_to_utf8 (setup->private_bin_path);
 603                 pvt_split = g_strsplit (utf8, G_SEARCHPATH_SEPARATOR_S, 1000);
 604                 g_free (utf8);
 605                 for (tmp = pvt_split; *tmp; tmp++, npaths++);
 606         }
 607
 608         if (!npaths) {
 609                 if (pvt_split)
 610                         g_strfreev (pvt_split);
 611                 /*
 612                  * Don't do this because the first time is called, the domain
 613                  * setup is not finished.
 614                  *
 615                  * domain->search_path = g_malloc (sizeof (char *));
 616                  * domain->search_path [0] = NULL;
 617                 */
 618                 return;
 619         }
 620
 621         if (domain->search_path)
 622                 g_strfreev (domain->search_path);
 623
 624         domain->search_path = tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
 625         tmp [npaths] = NULL;
 626
 627         *tmp = mono_string_to_utf8 (setup->application_base);
 628
 629         /* FIXME: is this needed? */
 630         if (strncmp (*tmp, "file://", 7) == 0) {
 631                 gchar *file = *tmp;
 632                 gchar *uri = *tmp;
 633                 gchar *tmpuri;
 634
 635                 if (uri [7] != '/')
 636                         uri = g_strdup_printf ("file:///%s", uri + 7);
 637
 638                 tmpuri = uri;
 639                 uri = mono_escape_uri_string (tmpuri);
 640                 *tmp = g_filename_from_uri (uri, NULL, &error);
 641                 g_free (uri);
 642
 643                 if (tmpuri != file)
 644                         g_free (tmpuri);
 645
 646                 if (error != NULL) {
 647                         g_warning ("%s\n", error->message);
 648                         g_error_free (error);
 649                         *tmp = file;
 650                 } else {
 651                         g_free (file);
 652                 }
 653         }
 654
 655         for (i = 1; pvt_split && i < npaths; i++) {
 656                 if (g_path_is_absolute (pvt_split [i - 1])) {
 657                         tmp [i] = g_strdup (pvt_split [i - 1]);
 658                 } else {
 659                         tmp [i] = g_build_filename (tmp [0], pvt_split [i - 1], NULL);
 660                 }
 661
 662                 if (strchr (tmp [i], '.')) {
 663                         gchar *reduced;
 664                         gchar *freeme;
 665
 666                         reduced = reduce_path (tmp [i]);
 667                         if (appbaselen == -1)
 668                                 appbaselen = strlen (tmp [0]);
 669
 670                         if (strncmp (tmp [0], reduced, appbaselen)) {
 671                                 g_free (reduced);
 672                                 g_free (tmp [i]);
 673                                 tmp [i] = g_strdup ("");
 674                                 continue;
 675                         }
 676
 677                         freeme = tmp [i];
 678                         tmp [i] = reduced;
 679                         g_free (freeme);
 680                 }
 681         }
 682
 683         if (setup->private_bin_path_probe != NULL) {
 684                 g_free (tmp [0]);
 685                 tmp [0] = g_strdup ("");
 686         }
 687
 688         domain->setup->path_changed = FALSE;
 689
 690         g_strfreev (pvt_split);
 691 }
 692
 693 static gboolean
 694 try_load_from (MonoAssembly **assembly, const gchar *path1, const gchar *path2,
 695                                         const gchar *path3, const gchar *path4)
 696 {
 697         gchar *fullpath;
 698
 699         *assembly = NULL;
 700         fullpath = g_build_filename (path1, path2, path3, path4, NULL);
 701         if (g_file_test (fullpath, G_FILE_TEST_IS_REGULAR))
 702                 *assembly = mono_assembly_open (fullpath, NULL);
 703
 704         g_free (fullpath);
 705         return (*assembly != NULL);
 706 }
 707
 708 static MonoAssembly *
 709 real_load (gchar **search_path, const gchar *culture, const gchar *name)
 710 {
 711         MonoAssembly *result = NULL;
 712         gchar **path;
 713         gchar *filename;
 714         const gchar *local_culture;
 715         gint len;
 716
 717         if (!culture || *culture == '\0') {
 718                 local_culture = "";
 719         } else {
 720                 local_culture = culture;
 721         }
 722
 723         filename =  g_strconcat (name, ".dll", NULL);
 724         len = strlen (filename);
 725
 726         for (path = search_path; *path; path++) {
 727                 if (**path == '\0')
 728                         continue; /* Ignore empty ApplicationBase */
 729
 730                 /* See test cases in bug #58992 and bug #57710 */
 731                 /* 1st try: [culture]/[name].dll (culture may be empty) */
 732                 strcpy (filename + len - 4, ".dll");
 733                 if (try_load_from (&result, *path, local_culture, "", filename))
 734                         break;
 735
 736                 /* 2nd try: [culture]/[name].exe (culture may be empty) */
 737                 strcpy (filename + len - 4, ".exe");
 738                 if (try_load_from (&result, *path, local_culture, "", filename))
 739                         break;
 740
 741                 /* 3rd try: [culture]/[name]/[name].dll (culture may be empty) */
 742                 strcpy (filename + len - 4, ".dll");
 743                 if (try_load_from (&result, *path, local_culture, name, filename))
 744                         break;
 745
 746                 /* 4th try: [culture]/[name]/[name].exe (culture may be empty) */
 747                 strcpy (filename + len - 4, ".exe");
 748                 if (try_load_from (&result, *path, local_culture, name, filename))
 749                         break;
 750         }
 751
 752         g_free (filename);
 753         return result;
 754 }
 755
 756 /*
 757  * Try loading the assembly from ApplicationBase and PrivateBinPath
 758  * and then from assemblies_path if any.
 759  */
 760 static MonoAssembly *
 761 mono_domain_assembly_preload (MonoAssemblyName *aname,
 762                               gchar **assemblies_path,
 763                               gpointer user_data)
 764 {
 765         MonoDomain *domain = mono_domain_get ();
 766         MonoAssembly *result = NULL;
 767
 768         set_domain_search_path (domain);
 769
 770         if (domain->search_path && domain->search_path [0] != NULL) {
 771                 result = real_load (domain->search_path, aname->culture, aname->name);
 772         }
 773
 774         if (result == NULL && assemblies_path && assemblies_path [0] != NULL) {
 775                 result = real_load (assemblies_path, aname->culture, aname->name);
 776         }
 777
 778         return NULL;
 779 }
 780
 781 MonoReflectionAssembly *
 782 ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
 783 {
 784         MonoDomain *domain = mono_domain_get ();
 785         char *name, *filename;
 786         MonoImageOpenStatus status = MONO_IMAGE_OK;
 787         MonoAssembly *ass;
 788
 789         MONO_ARCH_SAVE_REGS;
 790
 791         if (fname == NULL) {
 792                 MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
 793                 mono_raise_exception (exc);
 794         }
 795
 796         name = filename = mono_string_to_utf8 (fname);
 797
 798         ass = mono_assembly_open (filename, &status);
 799
 800         g_free (name);
 801
 802         if (!ass){
 803                 MonoException *exc = mono_get_exception_file_not_found (fname);
 804                 mono_raise_exception (exc);
 805         }
 806
 807         return mono_assembly_get_object (domain, ass);
 808 }
 809
 810 static void
 811 free_assembly_name (MonoAssemblyName *aname)
 812 {
 813         if (aname == NULL)
 814                 return;
 815
 816         g_free ((void *) aname->name);
 817         g_free ((void *) aname->culture);
 818         g_free ((void *) aname->hash_value);
 819 }
 820
 821 static gboolean
 822 get_info_from_assembly_name (MonoString *assRef, MonoAssemblyName *aname)
 823 {
 824         gchar *name;
 825         gchar *value;
 826         gchar **parts;
 827         gchar **tmp;
 828         gint major, minor, build, revision;
 829
 830         memset (aname, 0, sizeof (MonoAssemblyName));
 831
 832         name = mono_string_to_utf8 (assRef);
 833         parts = tmp = g_strsplit (name, ",", 4);
 834         g_free (name);
 835         if (!tmp || !*tmp) {
 836                 g_strfreev (tmp);
 837                 return FALSE;
 838         }
 839
 840         value = g_strstrip (*tmp);
 841         /* g_print ("Assembly name: %s\n", value); */
 842         aname->name = g_strdup (value);
 843         tmp++;
 844         if (!*tmp) {
 845                 g_strfreev (parts);
 846                 return TRUE;
 847         }
 848
 849         while (*tmp) {
 850                 value = g_strstrip (*tmp);
 851                 if (!g_ascii_strncasecmp (value, "Version=", 8)) {
 852                         if (sscanf (value + 8, "%u.%u.%u.%u",
 853                                     &major, &minor, &build, &revision) != 4) {
 854                                 g_strfreev (parts);
 855                                 return FALSE;
 856                         }
 857                         /* g_print ("Version: %u.%u.%u.%u\n", major, minor, build, revision); */
 858                         aname->major = major;
 859                         aname->minor = minor;
 860                         aname->build = build;
 861                         aname->revision = revision;
 862                         tmp++;
 863                         continue;
 864                 }
 865
 866                 if (!g_ascii_strncasecmp (value, "Culture=", 8)) {
 867                         gchar *t = g_strdup (value + 8);
 868                         g_strchug (t);
 869                         aname->culture = g_strdup (g_strchomp (t));
 870                         tmp++;
 871                         g_free (t);
 872                         if (g_strcasecmp (aname->culture, "neutral") == 0) {
 873                                 g_free ((void *) aname->culture);
 874                                 aname->culture = g_strdup ("");
 875                         }
 876                         continue;
 877                 }
 878
 879                 if (!g_ascii_strncasecmp (value, "PublicKeyToken=", 15)) {
 880                         tmp++;
 881                         value += 15;
 882                         if (*value && strncmp (value, "null", 4)) {
 883                                 gchar *t = g_strdup (value);
 884                                 g_strchug (t);
 885                                 g_strlcpy (aname->public_key_token, g_strchomp (value), MONO_PUBLIC_KEY_TOKEN_LENGTH);
 886                                 g_free (t);
 887                         }
 888                         continue;
 889                 }
 890
 891                 g_strfreev (parts);
 892                 return FALSE;
 893         }
 894
 895         g_strfreev (parts);
 896         return TRUE;
 897 }
 898
 899 MonoReflectionAssembly *
 900 ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
 901                                                                                         MonoArray *raw_assembly,
 902                                                                                         MonoArray *raw_symbol_store, MonoObject *evidence)
 903 {
 904         MonoAssembly *ass;
 905         MonoReflectionAssembly *refass = NULL;
 906         MonoDomain *domain = ad->data;
 907         MonoImageOpenStatus status;
 908         guint32 raw_assembly_len = mono_array_length (raw_assembly);
 909         MonoImage *image = mono_image_open_from_data (mono_array_addr (raw_assembly, gchar, 0), raw_assembly_len, TRUE, NULL);
 910
 911         if (raw_symbol_store)
 912                 mono_raise_exception (mono_get_exception_not_implemented ("LoadAssemblyRaw: Raw Symbol Store not Implemented"));
 913
 914         if (!image) {
 915                 mono_raise_exception (mono_get_exception_bad_image_format (""));
 916                 return NULL;
 917         }
 918
 919         ass = mono_assembly_load_from (image, "", &status);
 920
 921         if (!ass) {
 922                 mono_image_close (image);
 923                 mono_raise_exception (mono_get_exception_bad_image_format (""));
 924                 return NULL;
 925         }
 926
 927         refass = mono_assembly_get_object (domain, ass);
 928         refass->evidence = evidence;
 929         return refass;
 930 }
 931
 932 MonoReflectionAssembly *
 933 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoString *assRef, MonoObject *evidence)
 934 {
 935         MonoDomain *domain = ad->data;
 936         MonoImageOpenStatus status = MONO_IMAGE_OK;
 937         MonoAssembly *ass;
 938         MonoAssemblyName aname;
 939         MonoReflectionAssembly *refass = NULL;
 940
 941         MONO_ARCH_SAVE_REGS;
 942
 943         g_assert (assRef != NULL);
 944
 945         if (!get_info_from_assembly_name (assRef, &aname)) {
 946                 MonoException *exc;
 947
 948                 free_assembly_name (&aname);
 949                 /* This is a parse error... */
 950                 exc = mono_get_exception_file_not_found (assRef);
 951                 mono_raise_exception (exc);
 952         }
 953
 954         ass = mono_assembly_load (&aname, NULL, &status);
 955         free_assembly_name (&aname);
 956
 957         if (!ass && (refass = try_assembly_resolve (domain, assRef)) == NULL){
 958                 /* FIXME: it doesn't make much sense since we really don't have a filename ... */
 959                 MonoException *exc = mono_get_exception_file_not_found (assRef);
 960                 mono_raise_exception (exc);
 961         }
 962
 963         if (refass == NULL)
 964                 refass = mono_assembly_get_object (domain, ass);
 965
 966         refass->evidence = evidence;
 967         return refass;
 968 }
 969
 970 void
 971 ves_icall_System_AppDomain_InternalUnload (gint32 domain_id)
 972 {
 973         MonoDomain * domain = mono_domain_get_by_id (domain_id);
 974
 975         MONO_ARCH_SAVE_REGS;
 976
 977         if (NULL == domain) {
 978                 MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
 979                 mono_raise_exception (exc);
 980         }
 981
 982         if (domain == mono_get_root_domain ()) {
 983                 mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("The default appdomain can not be unloaded."));
 984                 return;
 985         }
 986
 987         /*
 988          * Unloading seems to cause problems when running NUnit/NAnt, hence
 989          * this workaround.
 990          */
 991         if (g_getenv ("MONO_NO_UNLOAD"))
 992                 return;
 993
 994         mono_domain_unload (domain);
 995 }
 996
 997 gboolean
 998 ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id)
 999 {
1000         MonoDomain *domain = mono_domain_get_by_id (domain_id);
1001
1002         if (!domain)
1003                 return TRUE;
1004
1005         return mono_domain_is_unloading (domain);
1006 }
1007
1008 gint32
1009 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
1010                                             MonoObject *evidence, MonoArray *args)
1011 {
1012         MonoAssembly *assembly;
1013         MonoImage *image;
1014         MonoMethod *method;
1015         char *filename;
1016         gint32 res;
1017         MonoReflectionAssembly *refass;
1018
1019         MONO_ARCH_SAVE_REGS;
1020
1021         filename = mono_string_to_utf8 (file);
1022         assembly = mono_assembly_open (filename, NULL);
1023         g_free (filename);
1024
1025         if (!assembly) {
1026                 mono_raise_exception ((MonoException *)mono_exception_from_name (
1027                         mono_defaults.corlib, "System.IO", "FileNotFoundException"));
1028         }
1029
1030         image = assembly->image;
1031
1032         method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
1033
1034         if (!method)
1035                 g_error ("No entry point method found in %s", image->name);
1036
1037         if (!args)
1038                 args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
1039
1040         refass = mono_assembly_get_object (ad->data, assembly);
1041         refass->evidence = evidence;
1042
1043         res = mono_runtime_exec_main (method, (MonoArray *)args, NULL);
1044
1045         return res;
1046 }
1047
1048 gint32
1049 ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad)
1050 {
1051         MONO_ARCH_SAVE_REGS;
1052
1053         return ad->data->domain_id;
1054 }
1055
1056 MonoAppDomain *
1057 ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad)
1058 {
1059         MonoDomain *old_domain = mono_domain_get();
1060
1061         MONO_ARCH_SAVE_REGS;
1062
1063         if (!mono_domain_set (ad->data, FALSE))
1064                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1065
1066         return old_domain->domain;
1067 }
1068
1069 MonoAppDomain *
1070 ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid)
1071 {
1072         MonoDomain *current_domain = mono_domain_get ();
1073         MonoDomain *domain = mono_domain_get_by_id (domainid);
1074
1075         MONO_ARCH_SAVE_REGS;
1076
1077         if (!domain || !mono_domain_set (domain, FALSE))
1078                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1079
1080         return current_domain->domain;
1081 }
1082
1083 void
1084 ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad)
1085 {
1086         MONO_ARCH_SAVE_REGS;
1087
1088         mono_thread_push_appdomain_ref (ad->data);
1089 }
1090
1091 void
1092 ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id)
1093 {
1094         MonoDomain *domain = mono_domain_get_by_id (domain_id);
1095
1096         MONO_ARCH_SAVE_REGS;
1097
1098         if (!domain)
1099                 /*
1100                  * Raise an exception to prevent the managed code from executing a pop
1101                  * later.
1102                  */
1103                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1104
1105         mono_thread_push_appdomain_ref (domain);
1106 }
1107
1108 void
1109 ves_icall_System_AppDomain_InternalPopDomainRef (void)
1110 {
1111         MONO_ARCH_SAVE_REGS;
1112
1113         mono_thread_pop_appdomain_ref ();
1114 }
1115
1116 MonoAppContext *
1117 ves_icall_System_AppDomain_InternalGetContext ()
1118 {
1119         MONO_ARCH_SAVE_REGS;
1120
1121         return mono_context_get ();
1122 }
1123
1124 MonoAppContext *
1125 ves_icall_System_AppDomain_InternalGetDefaultContext ()
1126 {
1127         MONO_ARCH_SAVE_REGS;
1128
1129         return mono_domain_get ()->default_context;
1130 }
1131
1132 MonoAppContext *
1133 ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc)
1134 {
1135         MonoAppContext *old_context = mono_context_get ();
1136
1137         MONO_ARCH_SAVE_REGS;
1138
1139         mono_context_set (mc);
1140
1141         return old_context;
1142 }
1143
1144 MonoString *
1145 ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid)
1146 {
1147         MonoDomain* mono_root_domain = mono_get_root_domain ();
1148         mono_domain_lock (mono_root_domain);
1149         if (process_guid_set) {
1150                 mono_domain_unlock (mono_root_domain);
1151                 return mono_string_new_utf16 (mono_domain_get (), process_guid, sizeof(process_guid)/2);
1152         }
1153         memcpy (process_guid, mono_string_chars(newguid), sizeof(process_guid));
1154         process_guid_set = TRUE;
1155         mono_domain_unlock (mono_root_domain);
1156         return newguid;
1157 }
1158
1159 gboolean
1160 mono_domain_is_unloading (MonoDomain *domain)
1161 {
1162         if (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED)
1163                 return TRUE;
1164         else
1165                 return FALSE;
1166 }
1167
1168 static void
1169 clear_cached_vtable (gpointer key, gpointer value, gpointer user_data)
1170 {
1171         MonoClass *klass = (MonoClass*)key;
1172         MonoDomain *domain = (MonoDomain*)user_data;
1173         MonoVTable *vt;
1174
1175         vt = klass->cached_vtable;
1176         if (vt && vt->domain == domain)
1177                 klass->cached_vtable = NULL;
1178 }
1179
1180 typedef struct unload_data {
1181         MonoDomain *domain;
1182         char *failure_reason;
1183 } unload_data;
1184
1185 static guint32
1186 unload_thread_main (void *arg)
1187 {
1188         unload_data *data = (unload_data*)arg;
1189         MonoDomain *domain = data->domain;
1190
1191         /*
1192          * FIXME: Abort our parent thread last, so we can return a failure
1193          * indication if aborting times out.
1194          */
1195         if (!mono_threads_abort_appdomain_threads (domain, 10000)) {
1196                 data->failure_reason = g_strdup_printf ("Aborting of threads in domain %s timed out.", domain->friendly_name);
1197                 return 1;
1198         }
1199
1200         /* Finalize all finalizable objects in the doomed appdomain */
1201         if (!mono_domain_finalize (domain, 10000)) {
1202                 data->failure_reason = g_strdup_printf ("Finalization of domain %s timed out.", domain->friendly_name);
1203                 return 1;
1204         }
1205
1206         /* Clear references to our vtables in class->cached_vtable */
1207         mono_domain_lock (domain);
1208         mono_g_hash_table_foreach (domain->class_vtable_hash, clear_cached_vtable,
1209                                                            domain);
1210         mono_domain_unlock (domain);
1211
1212         domain->state = MONO_APPDOMAIN_UNLOADED;
1213
1214         /* printf ("UNLOADED %s.\n", domain->friendly_name); */
1215
1216         mono_domain_free (domain, FALSE);
1217
1218 #ifdef HAVE_BOEHM_GC
1219         GC_gcollect ();
1220 #endif
1221
1222         return 0;
1223 }
1224
1225 /*
1226  * mono_domain_unload:
1227  *
1228  *  Unloads an appdomain. Follows the process outlined in:
1229  *  http://blogs.gotdotnet.com/cbrumme
1230  *  If doing things the 'right' way is too hard or complex, we do it the
1231  *  'simple' way, which means do everything needed to avoid crashes and
1232  *  memory leaks, but not much else.
1233  */
1234 static void
1235 mono_domain_unload (MonoDomain *domain)
1236 {
1237         HANDLE thread_handle;
1238         guint32 tid;
1239         MonoAppDomainState prev_state;
1240         MonoMethod *method;
1241         MonoObject *exc;
1242         unload_data thread_data;
1243
1244         /* printf ("UNLOAD STARTING FOR %s.\n", domain->friendly_name); */
1245
1246         /* Atomically change our state to UNLOADING */
1247         prev_state = InterlockedCompareExchange (&domain->state,
1248                                                                                          MONO_APPDOMAIN_UNLOADING,
1249                                                                                          MONO_APPDOMAIN_CREATED);
1250         if (prev_state != MONO_APPDOMAIN_CREATED) {
1251                 if (prev_state == MONO_APPDOMAIN_UNLOADING)
1252                         mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already being unloaded."));
1253                 else
1254                         if (prev_state == MONO_APPDOMAIN_UNLOADED)
1255                                 mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already unloaded."));
1256                 else
1257                         g_assert_not_reached ();
1258         }
1259
1260         /* Notify OnDomainUnload listeners */
1261         method = look_for_method_by_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload");
1262         g_assert (method);
1263
1264         exc = NULL;
1265         mono_runtime_invoke (method, domain->domain, NULL, &exc);
1266         if (exc) {
1267                 /* Roll back the state change */
1268                 domain->state = MONO_APPDOMAIN_CREATED;
1269                 mono_raise_exception ((MonoException*)exc);
1270         }
1271
1272         thread_data.domain = domain;
1273         thread_data.failure_reason = NULL;
1274
1275         /*
1276          * First we create a separate thread for unloading, since
1277          * we might have to abort some threads, including the current one.
1278          */
1279         /*
1280          * If we create a non-suspended thread, the runtime will hang.
1281          * See:
1282          * http://bugzilla.ximian.com/show_bug.cgi?id=27663
1283          */
1284 #if 0
1285         thread_handle = CreateThread (NULL, 0, unload_thread_main, &thread_data, 0, &tid);
1286 #else
1287 #if defined(PLATFORM_WIN32) && defined (HAVE_BOEHM_GC)
1288         thread_handle = GC_CreateThread (NULL, 0, unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
1289 #else
1290         thread_handle = CreateThread (NULL, 0, unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
1291 #endif
1292         ResumeThread (thread_handle);
1293 #endif
1294
1295         while (WaitForSingleObjectEx (thread_handle, INFINITE, FALSE) == WAIT_IO_COMPLETION)
1296                 ; /* wait for the thread */
1297
1298
1299         if (thread_data.failure_reason) {
1300                 MonoException *ex;
1301
1302                 ex = mono_get_exception_cannot_unload_appdomain (thread_data.failure_reason);
1303                 /* Roll back the state change */
1304                 domain->state = MONO_APPDOMAIN_CREATED;
1305
1306                 g_warning (thread_data.failure_reason);
1307
1308                 g_free (thread_data.failure_reason);
1309
1310                 mono_raise_exception (ex);
1311         }
1312 }