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