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